// AI数学助教 - MVP原型核心逻辑
class MathTutorAI {
    constructor() {
        this.canvas = document.getElementById('writingCanvas');
        this.ctx = this.canvas.getContext('2d');
        
        // 核心状态变量
        this.isDrawing = false;
        this.lastStrokeTime = Date.now();
        this.totalWritingTime = 0;
        this.pauseStartTime = null;
        this.currentPauseTime = 0;
        this.eraseCount = 0;
        this.helpLevel = 0; // 0-4，帮助级别
        this.strokeHistory = [];
        this.currentQuestionIndex = 0;
        
        // 学习状态监控
        this.learningState = {
            phase: 'thinking', // thinking, writing, stuck, helped
            startTime: Date.now(),
            isStuck: false,
            stuckStartTime: null,
            lastActivity: Date.now()
        };
        
        // 实时监控配置
        this.realtimeMonitoring = {
            enabled: true, // 默认启用监控
            interval: 5000, // 5秒监控一次
            lastAnalysisTime: 0,
            consecutiveErrors: 0,
            analysisHistory: [],
            monitoringTimer: null,
            isAnalyzing: false,
            lastAnalysisResult: null, // 新增：保存最后一次分析结果
            lastWritingTime: 0, // 新增：最后一次书写时间
            noWritingAnalysisCount: 0, // 新增：无书写情况下的分析次数
            lastNoWritingAnalysisTime: 0, // 新增：最后一次无书写分析时间
            maxNoWritingAnalysis: 2, // 新增：无书写情况下最大分析次数
            noWritingCooldown: 30000 // 新增：无书写分析冷却时间30秒
        };
        
        // 智能介入配置
        this.intelligentIntervention = {
            enabled: true,
            errorThreshold: 2, // 连续错误次数阈值
            interventionDelay: 1000, // 介入延迟
            interventionCooldown: 10000, // 介入冷却时间10秒
            lastInterventionTime: 0
        };
        
        // 题目库
        this.questions = [
            {
                id: 1,
                content: "小明家养了一些鸡和兔子，共有头16个，脚48只。请问鸡有多少只，兔子有多少只？",
                answer: "鸡8只，兔子8只",
                difficulty: "困难",
                hints: [
                    "这是一道鸡兔同笼问题，需要用方程思维解决",
                    "设鸡有x只，那么兔子有(16-x)只",
                    "鸡有2只脚，兔子有4只脚：2x + 4(16-x) = 48",
                    "解方程：2x + 64 - 4x = 48，所以x = 8。答案：鸡8只，兔子8只"
                ]
            },
            {
                id: 2,
                content: "一个长方形的长是宽的3倍，如果长方形的周长是48厘米，那么这个长方形的面积是多少平方厘米？",
                answer: "108平方厘米",
                difficulty: "较难",
                hints: [
                    "设宽为x厘米，那么长为3x厘米",
                    "长方形周长公式：周长 = 2(长 + 宽) = 2(3x + x) = 8x",
                    "根据题意：8x = 48，所以x = 6，长为18厘米，宽为6厘米",
                    "面积 = 长 × 宽 = 18 × 6 = 108平方厘米"
                ]
            },
            {
                id: 3,
                content: "甲、乙两人同时从A地出发到B地，甲每分钟走60米，乙每分钟走80米。如果乙比甲早到5分钟，那么A、B两地相距多少米？",
                answer: "1200米",
                difficulty: "困难",
                hints: [
                    "设A、B两地相距x米，甲走完全程需要x/60分钟",
                    "乙走完全程需要x/80分钟",
                    "根据题意：x/60 - x/80 = 5",
                    "解方程：4x/240 - 3x/240 = 5，所以x/240 = 5，x = 1200米"
                ]
            },
            {
                id: 4,
                content: "某商店有苹果和梨子共300个，苹果的个数是梨子的2倍多30个。苹果和梨子各有多少个？",
                answer: "苹果210个，梨子90个",
                difficulty: "较难",
                hints: [
                    "设梨子有x个，那么苹果有(2x + 30)个",
                    "根据题意：x + (2x + 30) = 300",
                    "化简：3x + 30 = 300，所以3x = 270，x = 90",
                    "梨子90个，苹果 = 2×90 + 30 = 210个。验算：90 + 210 = 300 ✓"
                ]
            },
            {
                id: 5,
                content: "一个三角形的底是8厘米，高是6厘米。如果底不变，高增加2厘米，那么面积增加多少平方厘米？",
                answer: "8平方厘米",
                difficulty: "中等",
                hints: [
                    "三角形面积公式：面积 = 底 × 高 ÷ 2",
                    "原来面积 = 8 × 6 ÷ 2 = 24平方厘米",
                    "高增加2厘米后，新高 = 6 + 2 = 8厘米",
                    "新面积 = 8 × 8 ÷ 2 = 32平方厘米，增加了32 - 24 = 8平方厘米"
                ]
            },
            {
                id: 6,
                content: "学校买来150本书，分给三年级和四年级。三年级分到的书是四年级的2倍。三年级和四年级各分到多少本书？",
                answer: "三年级100本，四年级50本",
                difficulty: "中等",
                hints: [
                    "设四年级分到x本书，那么三年级分到2x本书",
                    "根据题意：x + 2x = 150",
                    "化简：3x = 150，所以x = 50",
                    "四年级50本，三年级100本。验算：50 + 100 = 150 ✓"
                ]
            },
            {
                id: 7,
                content: "一个正方形的周长是32厘米，在这个正方形里画一个最大的圆，这个圆的面积是多少平方厘米？（π取3.14）",
                answer: "50.24平方厘米",
                difficulty: "困难",
                hints: [
                    "正方形周长32厘米，所以边长 = 32 ÷ 4 = 8厘米",
                    "最大的圆的直径等于正方形的边长，即8厘米",
                    "圆的半径 = 8 ÷ 2 = 4厘米",
                    "圆的面积 = π × r² = 3.14 × 4² = 3.14 × 16 = 50.24平方厘米"
                ]
            },
            {
                id: 8,
                content: "妈妈买了一些苹果，第一天吃了总数的1/4，第二天吃了剩下的1/3，还剩下12个。妈妈一共买了多少个苹果？",
                answer: "24个",
                difficulty: "困难",
                hints: [
                    "设一共买了x个苹果",
                    "第一天吃了x/4个，剩下3x/4个",
                    "第二天吃了剩下的1/3，即(3x/4) × (1/3) = x/4个",
                    "剩下的苹果：x - x/4 - x/4 = x/2 = 12，所以x = 24个"
                ]
            }
        ];
        
        // API配置
        this.apiConfig = {
            url: localStorage.getItem('api_url') || 'https://openrouter.ai/api/v1/chat/completions',
            key: localStorage.getItem('api_key') || '',
            model: localStorage.getItem('api_model') || 'anthropic/claude-3.5-sonnet',
            urlSelect: localStorage.getItem('api_url_select') || 'https://openrouter.ai/api/v1/chat/completions'
        };
        
        // 答题状态跟踪
        this.answerStatus = {
            isCorrect: false, // 当前答案是否正确
            lastCorrectTime: 0, // 最后一次答对的时间
            hasStartedWriting: false // 是否已经开始书写
        };
        
        // 用户主动操作状态跟踪
        this.userActionState = {
            lastActionTime: 0, // 最后一次主动操作时间
            actionType: '', // 操作类型：'submit' 或 'continue'
            shouldIgnoreLLMResponse: false, // 是否应该忽略LLM回复
            pendingLLMRequests: new Set() // 待处理的LLM请求ID
        };
        
        // UI状态管理
        this.uiState = {
            debugPanelCollapsed: true, // 监控中心默认收缩
            assistantCollapsed: true   // 助教默认收缩
        };
        
        this.init();
    }
    
    init() {
        console.log('初始化AI助教系统...');
        this.setupCanvas();
        this.setupEventListeners();
        this.setupUIControls(); // 设置UI控制
        this.initializeUIState(); // 初始化UI状态
        this.loadQuestion(0);
        this.startLearningMonitor();
        this.updateTime();
        
        // 初始化帮助级别指示器
        this.updateHelpLevelIndicator();
        
        // 确保AI助手初始显示
        this.showAssistantMessage("我是你的数学助教，遇到困难随时可以问我哦！", 0);
        
        // 强制创建并显示继续引导按钮（测试用）
        setTimeout(() => {
            console.log('🔧 强制创建继续引导按钮...');
            this.updateContinueGuideButton(1);
        }, 500);
        
        // 显示系统状态
        setTimeout(() => {
            this.showAssistantMessage("✅ 系统已启动！开始监控你的学习状态...", 0);
        }, 2000);
        
        setTimeout(() => {
            if (this.apiConfig.key) {
                this.showAssistantMessage("🤖 AI模型已连接，准备提供智能帮助！", 0);
                // 自动启动实时监控
                this.startRealtimeMonitoring();
            } else {
                this.showAssistantMessage("⚠️ 需要配置API密钥才能使用AI功能", 0);
                // 即使没有API密钥也启动基础监控
                this.startRealtimeMonitoring();
            }
        }, 4000);
        
        // 加载保存的监控设置
        this.loadMonitoringSettings();
        
        // 确保演示面板切换按钮始终显示
        const toggleBtn = document.getElementById('demoToggleBtn');
        if (toggleBtn) {
            toggleBtn.style.display = 'block';
        }
        
        // 翻页按钮现在通过CSS和HTML直接控制，无需JavaScript强制显示
        console.log('🔧 翻页按钮已通过CSS样式确保可见');
        
        console.log('✅ AI助教系统初始化完成');
    }
    
    setupCanvas() {
        // 设置canvas尺寸
        const rect = this.canvas.getBoundingClientRect();
        this.canvas.width = rect.width;
        this.canvas.height = rect.height;
        
        console.log('Canvas尺寸设置:', this.canvas.width, 'x', this.canvas.height);
        
        // 设置绘图样式
        this.ctx.strokeStyle = '#333';
        this.ctx.lineWidth = 2;
        this.ctx.lineCap = 'round';
        this.ctx.lineJoin = 'round';
        
        // 添加一些视觉提示
        this.ctx.fillStyle = '#f0f0f0';
        this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
        this.ctx.fillStyle = '#ccc';
        this.ctx.font = '14px Microsoft YaHei';
        this.ctx.fillText('在这里书写答案...', 20, 30);
    }
    
    setupEventListeners() {
        console.log('设置事件监听器...');
        
        // 检查关键按钮是否存在
        const prevBtn = document.getElementById('floatingPrevBtn');
        const nextBtn = document.getElementById('floatingNextBtn');
        const helpBtn = document.getElementById('helpBtn');
        const submitBtn = document.getElementById('submitBtn');
        
        console.log('🔍 按钮存在性检查:');
        console.log(`  - floatingPrevBtn: ${prevBtn ? '✅ 存在' : '❌ 不存在'}`);
        console.log(`  - floatingNextBtn: ${nextBtn ? '✅ 存在' : '❌ 不存在'}`);
        console.log(`  - helpBtn: ${helpBtn ? '✅ 存在' : '❌ 不存在'}`);
        console.log(`  - submitBtn: ${submitBtn ? '✅ 存在' : '❌ 不存在'}`);
        
        if (prevBtn) {
            console.log(`  - floatingPrevBtn样式: display=${getComputedStyle(prevBtn).display}, visibility=${getComputedStyle(prevBtn).visibility}`);
        }
        if (nextBtn) {
            console.log(`  - floatingNextBtn样式: display=${getComputedStyle(nextBtn).display}, visibility=${getComputedStyle(nextBtn).visibility}`);
        }
        
        // 画布绘图事件
        this.canvas.addEventListener('mousedown', this.startDrawing.bind(this));
        this.canvas.addEventListener('mousemove', this.draw.bind(this));
        this.canvas.addEventListener('mouseup', this.stopDrawing.bind(this));
        
        // 触摸事件支持
        this.canvas.addEventListener('touchstart', this.handleTouch.bind(this));
        this.canvas.addEventListener('touchmove', this.handleTouch.bind(this));
        this.canvas.addEventListener('touchend', this.stopDrawing.bind(this));
        
        // 工具按钮事件
        document.getElementById('clearBtn').addEventListener('click', () => {
            console.log('清除按钮被点击');
            this.clearCanvas();
        });
        document.getElementById('undoBtn').addEventListener('click', () => {
            console.log('撤销按钮被点击');
            this.undoLastStroke();
        });
        
        if (helpBtn) {
            helpBtn.addEventListener('click', () => {
                console.log('求助按钮被点击');
                this.requestHelp();
            });
        }
        
        if (submitBtn) {
            submitBtn.addEventListener('click', () => {
                console.log('提交按钮被点击');
                this.submitAnswer();
            });
        }
        
        if (nextBtn) {
            nextBtn.addEventListener('click', () => {
                console.log('下一题按钮被点击');
                this.nextQuestion();
            });
        }
        
        if (prevBtn) {
            prevBtn.addEventListener('click', () => {
                console.log('上一题按钮被点击');
                this.prevQuestion();
            });
        }
        
        // 窗口尺寸变化时重新设置canvas
        window.addEventListener('resize', this.setupCanvas.bind(this));
        
        // 键盘事件监听 - 左右箭头切换题目
        document.addEventListener('keydown', (e) => {
            // 检查是否在输入框中，如果是则不处理箭头键
            const activeElement = document.activeElement;
            const isInputActive = activeElement && (
                activeElement.tagName === 'INPUT' || 
                activeElement.tagName === 'TEXTAREA' ||
                activeElement.contentEditable === 'true'
            );
            
            if (!isInputActive) {
                switch(e.key) {
                    case 'ArrowLeft':
                        e.preventDefault();
                        this.prevQuestion();
                        console.log('⬅️ 键盘左箭头 - 切换到上一题');
                        break;
                    case 'ArrowRight':
                        e.preventDefault();
                        this.nextQuestion();
                        console.log('➡️ 键盘右箭头 - 切换到下一题');
                        break;
                }
            }
        });
        
        // 聊天输入框回车键事件
        document.getElementById('chatInput').addEventListener('keypress', (e) => {
            if (e.key === 'Enter') {
                this.sendChatMessage();
            }
        });
        
        console.log('✅ 事件监听器设置完成（包含键盘箭头切换功能）');
    }
    
    // 设置UI控制功能
    setupUIControls() {
        // 监控中心开关控制
        const debugPanel = document.getElementById('debugPanel');
        const debugTitle = debugPanel?.querySelector('h4');
        
        if (debugTitle) {
            debugTitle.addEventListener('click', () => {
                this.toggleDebugPanel();
            });
        }
        
        // 助教收缩展开控制
        const aiAssistant = document.getElementById('aiAssistant');
        const assistantAvatar = aiAssistant?.querySelector('.assistant-avatar');
        
        if (assistantAvatar) {
            assistantAvatar.addEventListener('click', () => {
                this.toggleAssistant();
            });
        }
    }
    
    // 初始化UI状态
    initializeUIState() {
        // 设置监控中心默认收缩状态
        const debugPanel = document.getElementById('debugPanel');
        if (debugPanel && this.uiState.debugPanelCollapsed) {
            debugPanel.classList.add('collapsed');
            console.log('📊 监控中心初始化为收缩状态');
        }
        
        // 设置助教默认收缩状态
        const aiAssistant = document.getElementById('aiAssistant');
        if (aiAssistant && this.uiState.assistantCollapsed) {
            aiAssistant.classList.add('collapsed');
            console.log('🤖 助教初始化为收缩状态');
        }
    }
    
    // 切换监控中心显示状态
    toggleDebugPanel() {
        const debugPanel = document.getElementById('debugPanel');
        if (!debugPanel) return;
        
        this.uiState.debugPanelCollapsed = !this.uiState.debugPanelCollapsed;
        
        if (this.uiState.debugPanelCollapsed) {
            debugPanel.classList.add('collapsed');
            console.log('📊 监控中心已收缩');
        } else {
            debugPanel.classList.remove('collapsed');
            console.log('📊 监控中心已展开');
        }
    }
    
    // 切换助教显示状态
    toggleAssistant() {
        const aiAssistant = document.getElementById('aiAssistant');
        if (!aiAssistant) return;
        
        this.uiState.assistantCollapsed = !this.uiState.assistantCollapsed;
        
        if (this.uiState.assistantCollapsed) {
            aiAssistant.classList.add('collapsed');
            console.log('🤖 助教已收缩');
        } else {
            aiAssistant.classList.remove('collapsed');
            console.log('🤖 助教已展开');
        }
    }
    
    // 展开助教（自动触发时使用）
    expandAssistant() {
        const aiAssistant = document.getElementById('aiAssistant');
        if (!aiAssistant) return;
        
        if (this.uiState.assistantCollapsed) {
            this.uiState.assistantCollapsed = false;
            aiAssistant.classList.remove('collapsed');
            console.log('🤖 助教自动展开');
        }
    }
    
    startDrawing(e) {
        this.isDrawing = true;
        this.currentStroke = [];
        
        // 更新书写状态
        this.answerStatus.hasStartedWriting = true;
        this.learningState.phase = 'writing';
        this.learningState.lastActivity = Date.now();
        
        // 记录书写开始时间
        if (!this.writingStartTime) {
            this.writingStartTime = Date.now();
            this.currentSessionWritingTime = 0;
        }
        this.realtimeMonitoring.lastWritingTime = Date.now();
        this.realtimeMonitoring.noWritingAnalysisCount = 0; // 重置无书写分析计数
        
        // 重置停顿计时 - 用户开始书写时重新启动监控
        this.pauseStartTime = null;
        this.currentPauseTime = 0;
        
        // 如果之前有用户主动操作，现在开始书写，重置操作状态
        if (this.userActionState.shouldIgnoreLLMResponse || 
            (Date.now() - this.userActionState.lastActionTime < 30000)) { // 30秒内的操作
            console.log('📝 用户开始书写，重置主动操作状态，重新启动停顿监控');
            this.userActionState.shouldIgnoreLLMResponse = false;
            this.userActionState.actionType = '';
        }
        
        const pos = this.getMousePos(e);
        this.currentStroke.push(pos);
        
        this.ctx.beginPath();
        this.ctx.moveTo(pos.x, pos.y);
        
        // 如果之前答案是正确的，现在开始新的书写，重置正确状态
        if (this.answerStatus.isCorrect) {
            this.answerStatus.isCorrect = false;
            this.answerStatus.lastCorrectTime = 0;
            this.updateCurrentStatus('正在书写');
            this.clearCorrectUI(); // 清除正确状态的UI
        }
    }
    
    draw(e) {
        if (!this.isDrawing) return;
        
        const pos = this.getMousePos(e);
        this.currentStroke.push(pos);
        
        this.ctx.lineTo(pos.x, pos.y);
        this.ctx.stroke();
        
        // 更新书写时间
        const now = Date.now();
        if (this.writingStartTime) {
            this.currentSessionWritingTime = now - this.writingStartTime;
            this.totalWritingTime = this.currentSessionWritingTime;
        }
        this.lastStrokeTime = now;
    }
    
    stopDrawing() {
        if (!this.isDrawing) return;
        
        this.isDrawing = false;
        
        // 保存当前笔画
        if (this.currentStroke.length > 0) {
            this.strokeHistory.push({
                stroke: [...this.currentStroke],
                timestamp: Date.now()
            });
            console.log(`✏️ 保存笔画 - 点数: ${this.currentStroke.length}, 总笔画数: ${this.strokeHistory.length}`);
            this.currentStroke = [];
        }
        
        // 开始停顿计时（只有在答案不正确且用户没有主动操作时才开始计时）
        if (!this.answerStatus.isCorrect && !this.userActionState.shouldIgnoreLLMResponse) {
            this.pauseStartTime = Date.now();
            this.learningState.phase = 'thinking';
            
            console.log('⏱️ 开始停顿计时，5秒后将自动分析');
            
            // 设置5秒后自动识别
            setTimeout(() => {
                // 再次检查用户是否有主动操作
                if (this.pauseStartTime && 
                    Date.now() - this.pauseStartTime >= 5000 && 
                    !this.userActionState.shouldIgnoreLLMResponse) {
                    console.log('🕐 停顿5秒，自动调用LLM分析');
                    this.autoAnalyzeWriting();
                }
            }, 5000);
        } else {
            console.log('⏸️ 跳过停顿计时 - 答案正确或用户有主动操作');
        }
        
        // 更新最后活动时间
        this.learningState.lastActivity = Date.now();
        
        console.log(`✏️ 完成书写，当前共有 ${this.strokeHistory.length} 个笔画`);
    }
    
    handleTouch(e) {
        e.preventDefault();
        const touch = e.touches[0];
        const mouseEvent = new MouseEvent(e.type.replace('touch', 'mouse'), {
            clientX: touch.clientX,
            clientY: touch.clientY
        });
        this.canvas.dispatchEvent(mouseEvent);
    }
    
    getMousePos(e) {
        const rect = this.canvas.getBoundingClientRect();
        return {
            x: e.clientX - rect.left,
            y: e.clientY - rect.top
        };
    }
    
    clearCanvas() {
        // 清除功能：清空整个画布的所有内容
        if (this.strokeHistory.length > 0) {
            this.eraseCount++;
            console.log('🧹 清除画布 - 清空所有内容');
        }
        
        this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
        this.strokeHistory = [];
        this.resetHelpLevel();
        
        // 显示清除反馈
        this.showAssistantMessage("画布已清空，可以重新开始书写", 0);
    }
    
    undoLastStroke() {
        // 撤销功能：只撤销最后一笔画
        if (this.strokeHistory.length === 0) {
            this.showAssistantMessage("没有可以撤销的笔画", 0);
            console.log('↩️ 撤销失败 - 没有笔画可撤销');
            return;
        }
        
        // 移除最后一笔画
        const removedStroke = this.strokeHistory.pop();
        
        // 兼容处理：支持旧格式（数组）和新格式（对象）
        let strokeLength;
        if (Array.isArray(removedStroke)) {
            strokeLength = removedStroke.length;
        } else if (removedStroke.stroke) {
            strokeLength = removedStroke.stroke.length;
        } else {
            strokeLength = 0;
        }
        
        console.log('↩️ 撤销最后一笔画 - 移除的笔画点数:', strokeLength);
        console.log('↩️ 剩余笔画数:', this.strokeHistory.length);
        
        // 重新绘制画布
        this.redrawCanvas();
        this.eraseCount++;
        
        // 更新实时监控的最后书写时间
        this.realtimeMonitoring.lastWritingTime = Date.now();
        
        // 显示撤销反馈
        if (this.strokeHistory.length > 0) {
            this.showAssistantMessage(`已撤销最后一笔，还有${this.strokeHistory.length}笔`, 0);
        } else {
            this.showAssistantMessage("已撤销最后一笔，画布已清空", 0);
        }
    }
    
    redrawCanvas() {
        this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
        
        this.strokeHistory.forEach((item, index) => {
            this.ctx.beginPath();
            
            // 兼容处理：支持旧格式（数组）和新格式（对象）
            let stroke;
            if (Array.isArray(item)) {
                // 旧格式：直接是点数组
                stroke = item;
            } else if (item.stroke) {
                // 新格式：对象包含stroke属性
                stroke = item.stroke;
            } else {
                console.warn(`无效的笔画数据格式，索引: ${index}`, item);
                return;
            }
            
            if (stroke && stroke.length > 0) {
                this.ctx.moveTo(stroke[0].x, stroke[0].y);
                for (let i = 1; i < stroke.length; i++) {
                    this.ctx.lineTo(stroke[i].x, stroke[i].y);
                }
                this.ctx.stroke();
            }
        });
        
        console.log(`🎨 重绘画布 - 绘制了 ${this.strokeHistory.length} 个笔画`);
    }
    
    // 核心AI功能：学习状态监控
    startLearningMonitor() {
        setInterval(() => {
            this.monitorLearningState();
            this.updateDebugPanel();
        }, 1000);
    }
    
    monitorLearningState() {
        const now = Date.now();
        
        // 检查是否已经答对题目 - 如果答对了就停止所有自动监控
        if (this.answerStatus.isCorrect) {
            // 答案正确时，停止所有自动监控行为
            this.learningState.isStuck = false;
            this.updateCurrentStatus('答题正确 - 监控已停止');
            this.showCorrectUI();
            console.log('✅ 答题正确，停止自动监控辅助');
            return; // 直接返回，不再进行任何自动监控
        }
        
        // 计算当前停顿时间
        if (this.pauseStartTime && !this.isDrawing) {
            this.currentPauseTime = Math.floor((now - this.pauseStartTime) / 1000);
        } else {
            this.currentPauseTime = 0;
        }
        
        // 只有在答案不正确且有书写内容时才进行停顿检测
        const hasWritingContent = this.strokeHistory.length > 0;
        this.answerStatus.hasStartedWriting = hasWritingContent;
        
        // 检测是否卡住了（缩短时间到5秒便于演示）
        if (this.currentPauseTime > 5 && !this.learningState.isStuck && hasWritingContent) {
            console.log('🚨 检测到学生可能卡住了！');
            this.detectStuckState();
        }
        
        // 自动提供帮助（缩短时间到10秒便于演示）
        // 只有在没有答对且有书写内容的情况下才自动提供帮助
        if (this.currentPauseTime > 10 && this.helpLevel === 0 && hasWritingContent) {
            console.log('🤖 自动提供帮助');
            this.autoProvideHelp();
        }
        
        // 更新学习阶段
        this.updateLearningPhaseAuto();
        
        // 实时监控状态检查
        this.checkRealtimeMonitoringHealth();
    }
    
    // 新增：检查当前答案是否正确
    checkIfAnswerIsCorrect() {
        // 如果有实时分析结果，优先使用
        if (this.realtimeMonitoring.lastAnalysisResult) {
            const result = this.realtimeMonitoring.lastAnalysisResult;
            return !result.hasError && result.confidence > 0.8;
        }
        
        // 否则进行简单的答案检查（基于书写内容是否包含正确答案）
        if (this.strokeHistory.length === 0) {
            return false; // 没有书写内容，肯定不正确
        }
        
        // 这里可以添加更复杂的答案检查逻辑
        // 暂时返回false，主要依赖实时分析结果
        return false;
    }
    
    detectStuckState() {
        // 如果已经答对题目，不再检测卡住状态
        if (this.answerStatus.isCorrect) {
            console.log('✅ 答题已正确，跳过卡住状态检测');
            return;
        }
        
        console.log('🚨 检测到学生可能卡住了');
        this.learningState.isStuck = true;
        this.learningState.stuckStartTime = Date.now();
        
        // UI反馈
        this.updateCurrentStatus('检测到困难，AI介入中');
        document.querySelector('.question-content').classList.add('stuck');
        document.querySelector('.ai-assistant').classList.add('urgent');
        
        // 直接介入，显示AI开始帮助的提示
        this.showAssistantMessage("🤖 我注意到你遇到了困难，让我来帮助你...", 1);
        
        // 立即调用AI帮助
        setTimeout(() => {
            this.autoProvideHelp();
        }, 1000);
    }
    
    async autoProvideHelp() {
        // 如果已经答对题目，不再自动提供帮助
        if (this.answerStatus.isCorrect) {
            console.log('✅ 答题已正确，停止自动提供帮助');
            return;
        }
        
        if (this.helpLevel >= 4) return;
        
        console.log('🤖 检测到学生卡顿，主动介入帮助');
        this.helpLevel = 1;
        
        if (this.apiConfig.key) {
            // 自动截图并识别
            const hasWriting = this.strokeHistory.length > 0;
            
            if (hasWriting) {
                this.showAssistantMessage("🔍 我发现你的解题过程中有些问题，让我帮你看看...", 1);
                
                // 自动截图识别并直接提供帮助
                const question = this.questions[this.currentQuestionIndex];
                const prompt = `学生在解这道题时停顿了${this.currentPauseTime}秒，可能遇到困难。请直接分析他写的内容并给出具体的指导建议，不要询问是否需要帮助：

题目：${question.content}

请直接指出问题所在并给出下一步的具体建议。`;
                
                try {
                    const helpText = await this.callAI(prompt, '', true);
                    setTimeout(() => {
                        this.showAssistantMessage(`💡 ${helpText}`, 2);
                    }, 2000);
                } catch (error) {
                    setTimeout(() => {
                        this.showAssistantMessage("我看到你停顿了一会儿，让我来帮你分析一下这道题。", 1);
                    }, 2000);
                }
            } else {
                // 没有手写内容时的直接帮助
                this.showAssistantMessage("🤔 我看到你还没有开始写，让我来帮你分析这道题。", 1);
                
                setTimeout(async () => {
                    const question = this.questions[this.currentQuestionIndex];
                    const prompt = `学生看这道题已经${this.currentPauseTime}秒了，但还没有开始写。请直接给出解题的第一步指导，不要询问：

题目：${question.content}

请直接告诉学生应该怎么开始解这道题。`;
                    
                    try {
                        const helpText = await this.callAI(prompt, '');
                        this.showAssistantMessage(`💡 ${helpText}`, 2);
                    } catch (error) {
                        this.showAssistantMessage("让我来帮你分析：首先读一遍题目，找出关键的数字和要求解的问题。", 2);
                    }
                }, 2000);
            }
        } else {
            this.provideHint();
        }
        
        this.updateCurrentStatus('正在提供帮助');
    }
    
    requestHelp() {
        this.helpLevel = Math.min(this.helpLevel + 1, 5);
        
        // 渐进式教学帮助级别说明
        const helpLevelTexts = [
            "第1级提示 - 给你一个思考方向",
            "第2级提示 - 告诉你解题思路", 
            "第3级提示 - 提供详细解题步骤",
            "第4级提示 - 给出完整解答过程",
            "第5级提示 - 深度讲解知识点"
        ];
        
        console.log(`🆘 求助请求 - 帮助级别: ${this.helpLevel}/4`);
        
        // 强制显示AI助手区域
        const assistant = document.getElementById('aiAssistant');
        if (assistant) {
            assistant.style.display = 'flex';
            assistant.style.visibility = 'visible';
            console.log('✅ AI助手区域已强制显示');
        }
        
        this.showAssistantMessage(`${helpLevelTexts[this.helpLevel - 1]}...`, this.helpLevel);
        
        if (this.apiConfig.key) {
            this.provideIntelligentHelp();
        } else {
            this.provideHint();
        }
        this.resetStuckTimer();
    }
    
    provideHint() {
        const question = this.questions[this.currentQuestionIndex];
        const hint = question.hints[this.helpLevel - 1];
        
        if (hint) {
            this.showAssistantMessage(hint, this.helpLevel);
            this.updateHelpLevelIndicator();
            
            // 标记为已帮助状态
            document.querySelector('.question-content').classList.remove('stuck');
            document.querySelector('.question-content').classList.add('helped');
        }
    }
    
    showAssistantMessage(message, level = 0) {
        const assistant = document.getElementById('aiAssistant');
        const messageEl = document.getElementById('assistantMessage');
        
        if (!assistant || !messageEl) {
            console.error('❌ AI助手元素未找到！');
            return;
        }
        
        // 如果助教处于收缩状态，自动展开
        if (this.uiState.assistantCollapsed) {
            this.expandAssistant();
        }
        
        // 确保助手区域可见
        assistant.style.display = 'flex';
        assistant.style.visibility = 'visible';
        
        // 添加动画效果
        messageEl.style.opacity = '0';
        setTimeout(() => {
            messageEl.textContent = message;
            messageEl.style.opacity = '1';
            messageEl.style.color = '#333';
            messageEl.style.fontSize = '14px';
        }, 150);
        
        assistant.classList.add('expanded');
        
        if (level > 2) {
            assistant.classList.add('urgent');
            assistant.style.background = '#fff3e0';
            assistant.style.borderTopColor = '#ff9800';
        } else {
            assistant.style.background = '#e3f2fd';
            assistant.style.borderTopColor = '#2196f3';
        }
        
        // 显示或隐藏继续引导按钮
        this.updateContinueGuideButton(level);
        
        console.log(`🤖 AI助手消息 (级别${level}): ${message}`);
        
        // 确保消息在页面中可见
        assistant.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
    }
    
    // 新增：更新继续引导按钮的显示状态
    updateContinueGuideButton(level) {
        console.log(`🔍 updateContinueGuideButton 被调用，级别: ${level}`);
        
        let continueBtn = document.getElementById('continueGuideBtn');
        console.log(`🔍 现有按钮: ${continueBtn ? '存在' : '不存在'}`);
        
        // 如果按钮不存在，创建它
        if (!continueBtn) {
            console.log('🔨 开始创建继续引导按钮...');
            continueBtn = document.createElement('button');
            continueBtn.id = 'continueGuideBtn';
            continueBtn.className = 'continue-guide-btn';
            continueBtn.innerHTML = '💡'; // 仅显示图标
            continueBtn.title = '继续引导'; // 鼠标悬停提示
            continueBtn.onclick = () => this.requestContinueGuide();
            
            // 将按钮插入到帮助级别指示器后面，聊天输入区域前面
            const helpLevelIndicator = document.getElementById('helpLevel');
            const chatInputArea = document.getElementById('chatInputArea');
            
            console.log(`🔍 helpLevelIndicator: ${helpLevelIndicator ? '存在' : '不存在'}`);
            console.log(`🔍 chatInputArea: ${chatInputArea ? '存在' : '不存在'}`);
            
            if (helpLevelIndicator && chatInputArea) {
                // 在帮助级别指示器和聊天输入区域之间插入按钮
                chatInputArea.parentNode.insertBefore(continueBtn, chatInputArea);
                console.log('✅ 继续引导按钮已创建并插入到合适位置');
            } else {
                // 备用方案：添加到assistant-content末尾
                const assistantContent = document.querySelector('.assistant-content');
                console.log(`🔍 assistantContent: ${assistantContent ? '存在' : '不存在'}`);
                if (assistantContent) {
                    assistantContent.appendChild(continueBtn);
                    console.log('✅ 继续引导按钮已创建（备用位置）');
                } else {
                    console.error('❌ 无法找到合适的位置插入按钮');
                    return;
                }
            }
        }
        
        // 强制显示按钮（测试用）
        console.log(`🔍 强制显示继续引导按钮，级别: ${level}`);
        continueBtn.style.display = 'block';
        continueBtn.style.visibility = 'visible';
        continueBtn.style.opacity = '1';
        
        if (this.apiConfig.key) {
            if (level < 3) {
                continueBtn.innerHTML = '💡'; // 基础提示
                continueBtn.title = `继续引导 (${level}/5)`;
            } else if (level < 5) {
                continueBtn.innerHTML = '🎯'; // 深度解答
                continueBtn.title = `深度解答 (${level}/5)`;
            } else {
                continueBtn.innerHTML = '📚'; // 知识讲解
                continueBtn.title = '知识点讲解';
            }
            continueBtn.disabled = false;
        } else {
            continueBtn.innerHTML = '💡'; // 仅显示图标
            continueBtn.title = '继续引导 (需配置AI)'; // 鼠标悬停提示
            continueBtn.disabled = true;
        }
        console.log(`✅ 继续引导按钮强制显示: ${continueBtn.textContent}`);
        console.log(`🔍 按钮样式: display=${continueBtn.style.display}, visibility=${continueBtn.style.visibility}, opacity=${continueBtn.style.opacity}`);
        
        // 验证按钮是否真的在DOM中
        const btnInDom = document.getElementById('continueGuideBtn');
        console.log(`🔍 按钮在DOM中: ${btnInDom ? '是' : '否'}`);
        if (btnInDom) {
            const computedStyle = getComputedStyle(btnInDom);
            console.log(`🔍 计算样式: display=${computedStyle.display}, visibility=${computedStyle.visibility}, opacity=${computedStyle.opacity}`);
        }
    }
    
    // 新增：手动触发继续引导
    async requestContinueGuide() {
        // 记录用户主动操作
        this.userActionState.lastActionTime = Date.now();
        this.userActionState.actionType = 'continue';
        this.userActionState.shouldIgnoreLLMResponse = true;
        
        // 停止当前的停顿监控
        this.pauseStartTime = null;
        this.currentPauseTime = 0;
        
        if (this.helpLevel >= 5) {
            if (this.answerStatus.isCorrect) {
                this.showAssistantMessage("恭喜你答对了！如果想了解更多相关知识，可以尝试下一题哦！", 0);
            } else {
                this.showAssistantMessage("已经提供了最详细的帮助，建议你尝试独立完成这道题！", 0);
            }
            // 重置用户操作状态
            this.userActionState.shouldIgnoreLLMResponse = false;
            return;
        }
        
        console.log('💡 用户手动请求继续引导');
        this.helpLevel = Math.min(this.helpLevel + 1, 5);
        
        // 如果题目已经答对，提供相关知识扩展
        if (this.answerStatus.isCorrect) {
            this.showAssistantMessage("很棒！你已经答对了！让我为你讲解一些相关的知识点...", this.helpLevel);
        } else {
            this.showAssistantMessage("正在为你准备下一步引导...", this.helpLevel);
        }
        
        try {
            // 调用AI提供更深入的帮助
            if (this.apiConfig.key) {
                await this.provideIntelligentHelp();
            } else {
                this.provideHint();
            }
        } finally {
            // 重置用户操作状态，但保持停顿监控暂停，直到下次书写
            this.userActionState.shouldIgnoreLLMResponse = false;
        }
    }
    
    updateHelpLevelIndicator() {
        const indicator = document.getElementById('helpLevel');
        indicator.innerHTML = '';
        
        for (let i = 0; i < 5; i++) {
            const dot = document.createElement('div');
            dot.className = 'help-level-dot';
            if (i < this.helpLevel) {
                dot.classList.add('active');
            }
            indicator.appendChild(dot);
        }
    }
    
    resetHelpLevel() {
        this.helpLevel = 0;
        this.updateHelpLevelIndicator();
        document.querySelector('.ai-assistant').classList.remove('urgent');
        this.showAssistantMessage("我是你的数学助教，遇到困难随时可以问我哦！", 0);
    }
    
    resetStuckTimer() {
        this.learningState.isStuck = false;
        this.learningState.stuckStartTime = null;
        this.pauseStartTime = Date.now();
        this.updateCurrentStatus('正常学习中');
        document.querySelector('.question-content').classList.remove('stuck');
        document.querySelector('.ai-assistant').classList.remove('urgent');
    }
    
    updateLearningPhase(phase) {
        this.learningState.phase = phase;
        
        switch(phase) {
            case 'reading':
                this.updateCurrentStatus('正在读题');
                break;
            case 'thinking':
                this.updateCurrentStatus('正在思考');
                break;
            case 'writing':
                this.updateCurrentStatus('正在书写');
                break;
            case 'checking':
                this.updateCurrentStatus('正在检查');
                break;
        }
    }
    
    updateLearningPhaseAuto() {
        // 根据行为自动判断学习阶段
        if (this.strokeHistory.length === 0) {
            this.updateLearningPhase('reading');
        } else if (this.currentPauseTime > 5) {
            this.updateLearningPhase('thinking');
        } else if (this.isDrawing) {
            this.updateLearningPhase('writing');
        }
    }
    
    loadQuestion(index) {
        console.log(`🔄 开始加载题目，索引: ${index}，题目总数: ${this.questions.length}`);
        
        if (index >= 0 && index < this.questions.length) {
            this.currentQuestionIndex = index;
            const question = this.questions[index];
            
            console.log(`📚 加载题目详情:`, question);
            
            // 清除之前的UI状态
            this.clearCorrectUI();
            
            // 重置答题状态
            this.answerStatus.isCorrect = false;
            this.answerStatus.lastCorrectTime = 0;
            this.answerStatus.hasStartedWriting = false;
            
            // 重置学习状态
            this.learningState.isStuck = false;
            this.learningState.stuckStartTime = null;
            this.learningState.phase = 'thinking';
            this.learningState.startTime = Date.now();
            this.learningState.lastActivity = Date.now();
            
            // 重置计数器
            this.eraseCount = 0;
            this.totalWritingTime = 0;
            this.currentSessionWritingTime = 0;
            this.writingStartTime = null;
            this.currentPauseTime = 0;
            this.pauseStartTime = null;
            
            // 重置监控状态
            this.realtimeMonitoring.consecutiveErrors = 0;
            this.realtimeMonitoring.lastAnalysisResult = null;
            this.realtimeMonitoring.lastWritingTime = 0;
            this.realtimeMonitoring.noWritingAnalysisCount = 0;
            this.realtimeMonitoring.lastNoWritingAnalysisTime = 0;
            
            // 重置用户操作状态
            this.userActionState.lastActionTime = 0;
            this.userActionState.actionType = '';
            this.userActionState.shouldIgnoreLLMResponse = false;
            this.userActionState.pendingLLMRequests.clear();
            
            // 更新UI
            const questionContentEl = document.getElementById('questionContent');
            if (questionContentEl) {
                questionContentEl.textContent = question.content;
                console.log(`✅ 题目内容已更新: ${question.content}`);
            } else {
                console.error('❌ 找不到questionContent元素');
            }
            
            // 更新题目进度显示
            const currentQuestionEl = document.getElementById('currentQuestion');
            const totalQuestionsEl = document.getElementById('totalQuestions');
            if (currentQuestionEl) {
                currentQuestionEl.textContent = index + 1;
                console.log(`✅ 当前题目编号已更新: ${index + 1}`);
            } else {
                console.error('❌ 找不到currentQuestion元素');
            }
            if (totalQuestionsEl) {
                totalQuestionsEl.textContent = this.questions.length;
                console.log(`✅ 总题目数已更新: ${this.questions.length}`);
            } else {
                console.error('❌ 找不到totalQuestions元素');
            }
            
            // 更新浮动翻页按钮状态
            const prevBtn = document.getElementById('floatingPrevBtn');
            const nextBtn = document.getElementById('floatingNextBtn');
            
            if (prevBtn) {
                prevBtn.disabled = (index === 0);
                console.log(`✅ 浮动上一题按钮: ${prevBtn.disabled ? '禁用' : '启用'} (第${index + 1}题)`);
            }
            
            if (nextBtn) {
                nextBtn.disabled = (index === this.questions.length - 1);
                console.log(`✅ 浮动下一题按钮: ${nextBtn.disabled ? '禁用' : '启用'} (第${index + 1}题)`);
            }
            
            // 重置帮助级别
            this.resetHelpLevel();
            
            // 清空画布
            this.clearCanvas();
            
            // 更新状态
            this.updateCurrentStatus('开始思考');
            
            // 显示题目难度
            this.showAssistantMessage(`📚 第${index + 1}题 (${question.difficulty})：开始思考吧！`, 0);
            
            console.log(`✅ 题目加载完成 ${index + 1}/${this.questions.length}: ${question.content} (${question.difficulty})`);
        } else {
            console.error(`❌ 无效的题目索引: ${index}，有效范围: 0-${this.questions.length - 1}`);
        }
    }
    
    nextQuestion() {
        console.log(`🔄 尝试切换到下一题，当前题目索引: ${this.currentQuestionIndex}，总题目数: ${this.questions.length}`);
        
        if (this.currentQuestionIndex < this.questions.length - 1) {
            console.log(`✅ 切换到第 ${this.currentQuestionIndex + 2} 题`);
            this.loadQuestion(this.currentQuestionIndex + 1);
        } else {
            console.log(`⚠️ 已经是最后一题了`);
            this.showAssistantMessage("🎉 已经是最后一题了！你可以重新练习前面的题目。", 0);
        }
    }
    
    prevQuestion() {
        console.log(`🔄 尝试切换到上一题，当前题目索引: ${this.currentQuestionIndex}，总题目数: ${this.questions.length}`);
        
        if (this.currentQuestionIndex > 0) {
            console.log(`✅ 切换到第 ${this.currentQuestionIndex} 题`);
            this.loadQuestion(this.currentQuestionIndex - 1);
        } else {
            console.log(`⚠️ 已经是第一题了`);
            this.showAssistantMessage("📚 已经是第一题了！", 0);
        }
    }
    
    async submitAnswer() {
        // 记录用户主动操作
        this.userActionState.lastActionTime = Date.now();
        this.userActionState.actionType = 'submit';
        this.userActionState.shouldIgnoreLLMResponse = true;
        
        // 停止当前的停顿监控
        this.pauseStartTime = null;
        this.currentPauseTime = 0;
        
        this.updateLearningPhase('checking');
        
        // 获取用户答案
        const answerInput = document.getElementById('answerInput');
        const userAnswer = answerInput ? answerInput.value.trim() : '';
        
        // 检查是否有答案
        const hasWrittenAnswer = userAnswer.length > 0;
        const hasDrawnAnswer = this.strokeHistory.length > 0;
        
        if (!hasWrittenAnswer && !hasDrawnAnswer) {
            this.showAssistantMessage("请先完成答题再提交哦！", 0);
            // 重置用户操作状态
            this.userActionState.shouldIgnoreLLMResponse = false;
            return;
        }
        
        // 更新提交按钮状态
        const submitBtn = document.getElementById('submitBtn');
        if (submitBtn) {
            submitBtn.disabled = true;
            submitBtn.textContent = '🔍 AI检查中...';
        }
        
        // 更新监控状态为分析中
        this.updateCurrentStatus('AI正在检查答案...');
        if (this.realtimeMonitoring.enabled) {
            this.updateMonitoringStatus('AI正在检查答案...', 'analyzing');
        }
        
        try {
            // 获取当前题目
            const questionEl = document.querySelector('.question p');
            const questionText = questionEl ? questionEl.textContent.trim() : '';
            
            // 尝试手写识别（如果有手写内容）
            let recognizedText = '';
            if (hasDrawnAnswer) {
                this.showAssistantMessage("正在识别你的手写内容...", 0);
                recognizedText = await this.recognizeHandwriting();
            }
            
            // 最终答案（优先使用手写识别结果）
            const finalAnswer = recognizedText || userAnswer;
            
            // 调用LLM检查答案
            const isCorrect = await this.checkAnswerWithLLM(questionText, finalAnswer, recognizedText);
            
            if (isCorrect) {
                // 答案正确
                this.answerStatus.isCorrect = true;
                this.answerStatus.lastCorrectTime = Date.now();
                
                // 显示正确状态UI
                this.showCorrectUI();
                
                // 更新助手消息
                const successMessage = recognizedText ? 
                    `🎉 答案正确！\n📝 识别结果：${recognizedText}` : 
                    `🎉 答案正确！做得很好！`;
                
                this.showAssistantMessage(successMessage, 0);
                
                // 更新监控状态
                this.updateCurrentStatus('答题正确');
                if (this.realtimeMonitoring.enabled) {
                    this.updateMonitoringStatus('答题正确', 'correct');
                }
                
                // 重置帮助级别
                this.resetHelpLevel();
                
                // 3秒后自动生成下一题
                setTimeout(() => {
                    this.nextQuestion();
                    // 清空输入
                    if (answerInput) answerInput.value = '';
                    this.clearCanvas();
                }, 3000);
                
            } else {
                // 答案错误，提供渐进式帮助
                this.showAssistantMessage("答案需要再想想，让我给你一些提示...", 1);
                
                // 更新监控状态
                this.updateCurrentStatus('答案错误，提供帮助');
                if (this.realtimeMonitoring.enabled) {
                    this.updateMonitoringStatus('答案错误，提供帮助', 'analyzing');
                }
                
                // 1.5秒后自动提供帮助
                setTimeout(() => {
                    this.requestHelp();
                }, 1500);
            }
            
        } catch (error) {
            console.error('答案检查失败:', error);
            
            // 错误处理 - 回退到简单反馈
            this.showAssistantMessage("答案已提交！继续努力练习！", 0);
            
            // 更新监控状态
            this.updateCurrentStatus('答案已提交');
            if (this.realtimeMonitoring.enabled) {
                this.updateMonitoringStatus('答案已提交', 'offline');
            }
            
            // 3秒后生成下一题
            setTimeout(() => {
                this.nextQuestion();
                if (answerInput) answerInput.value = '';
                this.clearCanvas();
            }, 3000);
        } finally {
            // 恢复提交按钮
            if (submitBtn) {
                submitBtn.disabled = false;
                submitBtn.textContent = '提交答案';
            }
            
            // 重置用户操作状态，但保持停顿监控暂停，直到下次书写
            this.userActionState.shouldIgnoreLLMResponse = false;
        }
    }
    
    // 使用LLM检查答案正确性
    async checkAnswerWithLLM(question, userAnswer, recognizedText = '') {
        if (!this.apiConfig.key) {
            console.log('没有配置API密钥，使用基础验证');
            return this.basicAnswerValidation(question, userAnswer);
        }
        
        try {
            const checkPrompt = `请检查学生的数学答案是否正确：

题目：${question}
学生答案：${userAnswer}
${recognizedText ? `手写识别：${recognizedText}` : ''}

检查要求：
1. 重点关注最终答案是否正确
2. 如果最终答案正确，即使步骤有小问题或不完整，也应该认定为正确
3. 只有当最终答案明显错误时，才判定为错误
4. 对于复杂题目，如果学生给出了主要的正确答案，应该认定为正确

回答格式：
- 如果最终答案正确，请回答：【正确】[可选的步骤建议]
- 如果最终答案错误，请回答：【错误】[错误说明]

示例：
- 学生答案是"8只鸡，8只兔子"，即使没有完整步骤，也应该回答：【正确】建议写出解题过程
- 学生答案是"10只鸡，6只兔子"，这时应该回答：【错误】答案不符合题目条件`;

            const response = await this.callAI(checkPrompt, '答案检查', false);
            
            // 解析AI回复 - 寻找明确的标记
            const isCorrect = response.includes('【正确】') || 
                            (response.includes('正确') && !response.includes('错误') && !response.includes('【错误】'));
            
            console.log(`AI答案检查结果: ${isCorrect ? '✅ 正确' : '❌ 错误'}`);
            return isCorrect;
            
        } catch (error) {
            console.error('LLM答案检查失败:', error);
            // 回退到基础验证
            return this.basicAnswerValidation(question, userAnswer);
        }
    }
    
    // 基础答案验证（备用方案）
    basicAnswerValidation(question, userAnswer) {
        // 简单的数字答案验证
        const numbers = question.match(/\d+/g);
        if (numbers && numbers.length >= 2) {
            const num1 = parseInt(numbers[0]);
            const num2 = parseInt(numbers[1]);
            const userNum = parseInt(userAnswer);
            
            if (question.includes('+')) {
                return userNum === (num1 + num2);
            } else if (question.includes('-')) {
                return userNum === (num1 - num2);
            } else if (question.includes('×') || question.includes('*')) {
                return userNum === (num1 * num2);
            } else if (question.includes('÷') || question.includes('/')) {
                return userNum === Math.floor(num1 / num2);
            }
        }
        
        // 如果无法验证，默认为正确（鼓励学生）
        return true;
    }
    
    updateDebugPanel() {
        const debugInfo = document.getElementById('debugInfo');
        if (!debugInfo) return;
        
        const realtimeStatus = this.realtimeMonitoring.enabled ? '🟢 运行中' : '🔴 已停止';
        const lastAnalysis = this.realtimeMonitoring.lastAnalysisTime ? 
            new Date(this.realtimeMonitoring.lastAnalysisTime).toLocaleTimeString() : '未分析';
        
        debugInfo.innerHTML = `
            <strong>📊 学习状态监控</strong><br>
            当前阶段: ${this.learningState.phase}<br>
            停顿时间: ${this.currentPauseTime}秒<br>
            书写时间: ${Math.floor(this.totalWritingTime / 1000)}秒<br>
            涂改次数: ${this.eraseCount}次<br>
            帮助级别: ${this.helpLevel}/5<br>
            笔画数量: ${this.strokeHistory.length}<br>
            <br>
            <strong>🔍 实时监控状态</strong><br>
            监控状态: ${realtimeStatus}<br>
            最后分析: ${lastAnalysis}<br>
            连续错误: ${this.realtimeMonitoring.consecutiveErrors}次<br>
            分析历史: ${this.realtimeMonitoring.analysisHistory.length}条<br>
            正在分析: ${this.realtimeMonitoring.isAnalyzing ? '是' : '否'}
        `;
    }
    
    updateTime() {
        const now = new Date();
        document.getElementById('currentTime').textContent = 
            now.getHours().toString().padStart(2, '0') + ':' + 
            now.getMinutes().toString().padStart(2, '0');
            
        setTimeout(() => this.updateTime(), 1000);
    }
    
    // 演示功能
    async demoStuckDetection() {
        console.log('🎯 演示卡顿检测功能');
        this.showAssistantMessage("演示：模拟学生卡住的情况...", 0);
        
        // 模拟卡住状态
        this.currentPauseTime = 15;
        this.learningState.isStuck = true;
        
        setTimeout(() => {
            this.detectStuckState();
            if (this.apiConfig.key) {
                this.provideIntelligentHelp();
            }
        }, 2000);
    }
    
    async demoWritingAnalysis() {
        console.log('✍️ 演示书写分析功能');
        
        // 模拟一些书写数据
        this.totalWritingTime += 30000; // 30秒
        this.eraseCount += 2;
        this.strokeHistory.push({
            stroke: [{x: 100, y: 100}, {x: 150, y: 150}],
            timestamp: Date.now()
        });
        
        if (this.apiConfig.key) {
            this.showAssistantMessage("正在分析你的书写模式...", 1);
            
            const analysis = await this.callAI(
                "请根据学生的书写数据给出简短的学习状态分析和建议。",
                `书写时间: 30秒, 涂改次数: 2次, 笔画数量: ${this.strokeHistory.length}`
            );
            
            setTimeout(() => {
                this.showAssistantMessage(analysis, 0);
            }, 1500);
        } else {
            this.showAssistantMessage("书写分析完成！建议配置AI模型获得更智能的分析。", 0);
        }
    }
    
    testAIAssistant() {
        console.log('🧪 测试AI助手功能');
        
        if (this.apiConfig.key) {
            this.provideIntelligentHelp();
        } else {
            this.showAPIConfigDialog();
        }
    }
    
    // 画布截图方法
    captureCanvasImage() {
        try {
            // 获取canvas的截图数据（base64格式）
            const imageData = this.canvas.toDataURL('image/png');
            console.log('📸 画布截图成功');
            return imageData;
        } catch (error) {
            console.error('截图失败:', error);
            return null;
        }
    }
    
    // 安全的fetch包装函数
    async safeFetch(url, options) {
        // 确保所有header值都是ASCII字符
        const safeHeaders = {};
        if (options.headers) {
            for (const [key, value] of Object.entries(options.headers)) {
                // 将非ASCII字符转换为安全的ASCII字符
                safeHeaders[key] = String(value).replace(/[^\x00-\x7F]/g, '');
            }
        }
        
        return fetch(url, {
            ...options,
            headers: safeHeaders
        });
    }
    
    // AI模型调用方法（支持图像）
    async callAI(prompt, context = '', includeImage = false) {
        if (!this.apiConfig.key) {
            return '⚠️ 请先配置API密钥才能使用AI功能';
        }
        
        try {
            // 检测是否使用豆包模型
            const isDoubaoModel = this.apiConfig.model.toLowerCase().includes('doubao') || 
                                 this.apiConfig.model.toLowerCase().includes('ui-tars') ||
                                 this.apiConfig.model.toLowerCase().includes('vision');
            
            // 检测是否使用火山方舟API
            const isVolcesAPI = this.apiConfig.url.includes('ark.cn-beijing.volces.com');
            
            let systemPrompt = `你是一位经验丰富的小学数学老师，专门进行渐进式教学辅导。

渐进式教学核心：
- 根据学生求助次数，提供不同程度的帮助
- 第1次：只给最小提示，激发思考
- 第2次：指出大方向，不给具体方法
- 第3次：给出关键第一步，引导继续
- 第4次：提供完整思路，让学生计算

教学语言：
- 用"你"称呼学生，多说"我们一起"
- 语气温和鼓励，像坐在身边的老师
- 绝不提及AI、分析、技术等词汇
- 根据帮助级别严格控制信息量

当前教学情况：${context}`;

            // 如果是豆包模型，使用专门优化的提示词
            if (isDoubaoModel) {
                systemPrompt = `你是一位温暖的小学数学老师，正在进行渐进式教学辅导。

豆包AI教学特色：
- 像真正的老师一样温和地与学生交流
- 严格按照渐进式教学原则提供帮助
- 直接开始教学，绝不提及AI或技术
- 用"你"称呼学生，用"我们"拉近距离
- 根据帮助级别精确控制指导程度

渐进式原则：
- 帮助级别1：最小提示，让学生思考
- 帮助级别2：指出方向，不给方法
- 帮助级别3：给第一步，引导下一步
- 帮助级别4：完整思路，学生计算

教学场景：${context}`;
            } else {
                // 对于其他视觉模型的渐进式教学提示词
                systemPrompt = `你是一位有经验的小学数学老师，专门进行渐进式教学辅导。

渐进式教学策略：
- 通过观察学生书写了解学习进度
- 根据帮助级别提供相应程度的指导
- 用温暖鼓励的语气与学生交流
- 直接开始教学引导，不要提及AI

教学级别控制：
- 级别1：简单提示，激发思考（20字内）
- 级别2：指出方向，不透露方法（30字内）
- 级别3：给出第一步，引导继续（40字内）
- 级别4：完整思路，让学生计算（50字内）

工作原则：
- 严格按级别控制信息量
- 用"你"称呼，语言亲切自然
- 支持图像和文字的综合理解

当前分析场景：${context}`;
            }

            const messages = [
                {
                    role: 'system',
                    content: systemPrompt
                }
            ];
            
            // 构建用户消息
            let userMessage = {
                role: 'user',
                content: []
            };
            
            // 添加文本内容
            userMessage.content.push({
                type: 'text',
                text: prompt
            });
            
            // 如果需要包含图像且有手写内容
            if (includeImage && this.strokeHistory.length > 0) {
                const imageData = this.captureCanvasImage();
                if (imageData) {
                    userMessage.content.push({
                        type: 'image_url',
                        image_url: {
                            url: imageData
                        }
                    });
                    console.log('🖼️ 已包含手写内容图像');
                }
            }
            
            // 如果没有图像内容，使用简单的文本格式
            if (!includeImage || userMessage.content.length === 1) {
                userMessage = {
                    role: 'user',
                    content: prompt
                };
            }
            
            messages.push(userMessage);
            
            // 为豆包模型调整参数
            const requestBody = {
                model: this.apiConfig.model,
                messages: messages,
                max_tokens: isDoubaoModel ? 200 : 150,
                temperature: isDoubaoModel ? 0.6 : 0.7
            };
            
            // 如果是豆包UI-TARS模型，添加特殊参数
            if (this.apiConfig.model.toLowerCase().includes('ui-tars')) {
                requestBody.stream = false;
                requestBody.top_p = 0.9;
            }
            
            // 构建正确的API URL
            let apiUrl = this.apiConfig.url;
            if (isVolcesAPI && !apiUrl.endsWith('/chat/completions')) {
                apiUrl = apiUrl.endsWith('/') ? apiUrl + 'chat/completions' : apiUrl + '/chat/completions';
            }
            
            const response = await this.safeFetch(apiUrl, {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.apiConfig.key}`,
                    'Content-Type': 'application/json',
                    'HTTP-Referer': window.location.origin,
                    'X-Title': 'AI-Math-Tutor'
                },
                body: JSON.stringify(requestBody)
            });
            
            if (!response.ok) {
                const errorText = await response.text();
                throw new Error(`API调用失败: ${response.status} - ${errorText}`);
            }
            
            const data = await response.json();
            console.log('AI响应数据:', data);
            
            if (data.choices && data.choices.length > 0 && data.choices[0].message) {
                return data.choices[0].message.content.trim();
            } else {
                throw new Error('AI响应格式异常');
            }
            
        } catch (error) {
            console.error('AI调用错误:', error);
            return `❌ AI服务暂时不可用: ${error.message}`;
        }
    }
    
    // 智能帮助提供 - 真正的渐进式引导
    async provideIntelligentHelp() {
        const question = this.questions[this.currentQuestionIndex];
        const hasWriting = this.strokeHistory.length > 0;
        
        // 如果题目已经答对，提供知识扩展内容
        if (this.answerStatus.isCorrect) {
            const prompt = `学生已经正确回答了这道题，现在想了解更多相关知识。请为这道题提供知识扩展：

题目：${question.content}
正确答案：${question.answer}

请提供以下内容之一：
1. 相关的数学概念解释
2. 类似题型的变化
3. 这类题目的解题技巧
4. 实际生活中的应用
5. 相关的数学小知识

控制在60字以内，要有趣且有教育意义。`;

            const context = `
当前题目: ${question.content}
答题状态: 已正确
帮助级别: ${this.helpLevel}/5 (知识扩展)
            `;

            const helpText = await this.callAI(prompt, context, false);
            
            setTimeout(() => {
                if (!this.userActionState.shouldIgnoreLLMResponse) {
                    this.showAssistantMessage(`🎓 ${helpText}`, this.helpLevel);
                } else {
                    console.log('🚫 用户有主动操作，忽略知识扩展回复');
                }
            }, 1500);
            return;
        }
        
        // 题目未答对时的常规引导
        let guidanceLevel = '';
        let prompt = '';
        
        switch(this.helpLevel) {
            case 1:
                guidanceLevel = '第一次提示：只给一个小小的启发，让学生自己思考';
                prompt = `学生第一次求助，请给一个非常简单的提示或启发，不要透露解题方法。比如"仔细看看题目中的关键信息"或"想想这类题目通常用什么方法"。控制在20字以内。`;
                break;
            case 2:
                guidanceLevel = '第二次提示：指出解题思路方向，但不给具体步骤';
                prompt = `学生第二次求助，可以指出解题的大方向或思路，但不要给出具体步骤。比如"这是一道方程题，需要设未知数"。控制在30字以内。`;
                break;
            case 3:
                guidanceLevel = '第三次提示：给出解题的第一步，引导下一步思考';
                prompt = `学生第三次求助，可以给出解题的第一步或关键步骤，然后引导学生思考下一步。控制在40字以内。`;
                break;
            case 4:
                guidanceLevel = '第四次提示：提供完整的解题思路，但让学生自己计算';
                prompt = `学生第四次求助，可以提供比较完整的解题思路和方法，但仍要让学生自己动手计算。控制在50字以内。`;
                break;
            default:
                guidanceLevel = '基础提示';
                prompt = `给学生一个鼓励性的提示，让他们重新审视题目。`;
        }
        
        const context = `
当前题目: ${question.content}
难度: ${question.difficulty}
帮助级别: ${this.helpLevel}/4 (${guidanceLevel})
学生状态: ${hasWriting ? '已开始书写' : '还未开始书写'}
书写时间: ${Math.floor(this.totalWritingTime / 1000)}秒
停顿时间: ${this.currentPauseTime}秒
        `;
        
        this.showAssistantMessage(`正在为你准备第${this.helpLevel}级提示...`, 1);
        
        const helpText = await this.callAI(prompt, context, hasWriting);
        
        setTimeout(() => {
            // 检查用户是否有主动操作，如果有则忽略回复
            if (!this.userActionState.shouldIgnoreLLMResponse) {
                this.showAssistantMessage(helpText, this.helpLevel);
            } else {
                console.log('🚫 用户有主动操作，忽略智能帮助回复');
            }
        }, 1500);
    }
    
    // 自动分析书写内容（停顿5秒后调用）- 渐进式引导
    async autoAnalyzeWriting() {
        console.log('🔍 自动分析书写内容');
        
        // 检查用户是否有主动操作，如果有则跳过分析
        if (this.userActionState.shouldIgnoreLLMResponse) {
            console.log('⏸️ 用户有主动操作，跳过自动分析');
            return;
        }
        
        if (this.strokeHistory.length === 0) {
            console.log('画布上没有内容，跳过自动分析');
            return;
        }
        
        if (!this.apiConfig.key) {
            this.showAssistantMessage("需要配置API密钥才能使用AI分析功能", 0);
            return;
        }
        
        this.showAssistantMessage("我注意到你停顿了一下，让我看看能不能帮到你...", 1);
        
        const question = this.questions[this.currentQuestionIndex];
        
        // 自动分析时给予温和的引导，不要过于直接
        const prompt = `你是一位温和的数学老师，学生停顿了5秒。请观察学生的书写内容，给出温和的引导。

重要原则：
- 如果学生写得对，给予鼓励
- 如果发现小错误，温和地提醒
- 如果学生卡住了，给一个小提示
- 不要直接指出答案或完整方法
- 语气要像老师在身边轻声提醒
- 控制在25字以内

当前题目：${question.content}`;
        
        try {
            const analysis = await this.callAI(prompt, '', true);
            
            setTimeout(() => {
                // 再次检查用户是否有主动操作
                if (!this.userActionState.shouldIgnoreLLMResponse) {
                    this.showAssistantMessage(analysis, 0);
                } else {
                    console.log('🚫 用户有主动操作，忽略自动分析回复');
                }
            }, 1500);
            
        } catch (error) {
            console.error('自动分析失败:', error);
            if (!this.userActionState.shouldIgnoreLLMResponse) {
                this.showAssistantMessage("我在观察你的解题过程，有困难随时求助哦", 0);
            }
        }
    }

    // 手写识别功能
    async recognizeHandwriting() {
        if (this.strokeHistory.length === 0) {
            this.showAssistantMessage("画布上没有内容哦，先写点什么吧！", 0);
            return;
        }
        
        if (!this.apiConfig.key) {
            this.showAPIConfigDialog();
            return;
        }
        
        this.showAssistantMessage("🔍 正在识别你写的内容...", 1);
        
        const question = this.questions[this.currentQuestionIndex];
        const prompt = `请识别这张手写内容图片中的数字、算式或文字。这是小学生在解决以下数学题时写的：
        
题目：${question.content}

请告诉我你在图片中看到了什么数字或算式，并简单分析学生的解题思路是否正确。`;
        
        try {
            const recognitionResult = await this.callAI(prompt, '', true);
            
            setTimeout(() => {
                this.showAssistantMessage(`📝 识别结果：${recognitionResult}`, 0);
            }, 1500);
            
        } catch (error) {
            setTimeout(() => {
                this.showAssistantMessage("❌ 手写识别失败，请检查网络连接", 0);
            }, 1500);
        }
    }
    
    // 聊天功能
    toggleChatInput() {
        const chatArea = document.getElementById('chatInputArea');
        const toggleBtn = document.getElementById('chatToggleBtn');
        
        if (chatArea.style.display === 'none') {
            chatArea.style.display = 'flex';
            toggleBtn.textContent = '📝';
            document.getElementById('chatInput').focus();
        } else {
            chatArea.style.display = 'none';
            toggleBtn.textContent = '💬';
        }
    }
    
    closeChatInput() {
        document.getElementById('chatInputArea').style.display = 'none';
        document.getElementById('chatToggleBtn').textContent = '💬';
    }
    
    async sendChatMessage() {
        const input = document.getElementById('chatInput');
        const message = input.value.trim();
        
        if (!message) return;
        
        if (!this.apiConfig.key) {
            this.showAssistantMessage("请先配置AI模型才能与我聊天哦！", 0);
            this.showAPIConfigDialog();
            return;
        }
        
        // 清空输入框
        input.value = '';
        
        // 显示学生的问题
        this.showAssistantMessage(`👦 你问：${message}`, 0);
        
        // 显示AI思考中
        setTimeout(() => {
            this.showAssistantMessage("🤔 让我想想...", 1);
        }, 500);
        
        // 获取当前题目上下文
        const question = this.questions[this.currentQuestionIndex];
        const hasWriting = this.strokeHistory.length > 0;
        
        const context = `
当前题目: ${question.content}
学生手写内容: ${hasWriting ? '有内容' : '无内容'}
学生问题: ${message}
        `;
        
        const prompt = `学生问了一个问题："${message}"。请根据当前的数学题目和学习情况，给出简短、友好的回答。要像一个耐心的老师一样回应。`;
        
        try {
            const response = await this.callAI(prompt, context, hasWriting);
            
            setTimeout(() => {
                this.showAssistantMessage(`🤖 ${response}`, 0);
            }, 1500);
            
        } catch (error) {
            setTimeout(() => {
                this.showAssistantMessage("抱歉，我现在有点忙，稍后再试试吧！", 0);
            }, 1500);
        }
    }
    
    // 显示API配置对话框，增加豆包模型选项
    showAPIConfigDialog() {
        // 检查是否已存在对话框
        const existingDialog = document.getElementById('apiConfigDialog');
        if (existingDialog) {
            existingDialog.remove();
        }
        
        const dialog = document.createElement('div');
        dialog.id = 'apiConfigDialog';
        dialog.className = 'api-config-dialog';
        dialog.innerHTML = `
            <div class="api-config-content">
                <h3>🔧 AI模型配置</h3>
                <div class="config-section">
                    <label>API服务地址:</label>
                    <select id="apiUrlSelect" onchange="updateApiUrl()">
                        <option value="https://openrouter.ai/api/v1/chat/completions">OpenRouter (推荐)</option>
                        <option value="https://api.openai.com/v1/chat/completions">OpenAI 官方</option>
                        <option value="https://ark.cn-beijing.volces.com/api/v3/chat/completions">火山方舟 (豆包模型)</option>
                        <option value="custom">自定义地址</option>
                    </select>
                    <input type="text" id="apiUrl" placeholder="或输入自定义API地址" 
                           value="${this.apiConfig.url}" style="margin-top: 8px;">
                </div>
                
                <div class="config-section">
                    <label>API密钥:</label>
                    <input type="password" id="apiKey" placeholder="输入你的API密钥" 
                           value="${this.apiConfig.key}">
                    <small>💡 支持OpenRouter、OpenAI、火山方舟等平台</small>
                </div>
                
                <div class="config-section">
                    <label>AI模型:</label>
                    <select id="apiModel">
                        <optgroup label="🔥 推荐模型 (视觉支持)">
                            <option value="anthropic/claude-3.5-sonnet">Claude 3.5 Sonnet (强推荐)</option>
                            <option value="openai/gpt-4o">GPT-4O (视觉理解)</option>
                            <option value="openai/gpt-4-vision-preview">GPT-4 Vision</option>
                        </optgroup>
                        <optgroup label="🚀 豆包模型 (火山方舟)">
                            <option value="doubao-1.5-ui-tars">豆包 UI-TARS (GUI专用)</option>
                            <option value="doubao-1.5-vision-pro-250328">Doubao-1.5-vision-pro</option>
                            <option value="doubao-1.5-vision-lite-250315">Doubao-1.5-vision-lite</option>
                            <option value="doubao-1-5-vision-pro-32k-250115">Doubao-1.5-vision-pro-32k
</option>
                        </optgroup>
                        <optgroup label="📝 文本模型">
                            <option value="anthropic/claude-3-haiku">Claude 3 Haiku (快速)</option>
                            <option value="openai/gpt-3.5-turbo">GPT-3.5 Turbo (经济)</option>
                            <option value="meta-llama/llama-3.1-8b-instruct">Llama 3.1 8B</option>
                        </optgroup>
                    </select>
                    <small>💡 视觉模型支持手写识别，豆包模型针对中文优化</small>
                </div>
                
                <div class="config-section">
                    <label>🔍 实时监控设置:</label>
                    <div style="display: flex; align-items: center; gap: 10px; margin-top: 5px;">
                        <label style="font-size: 12px;">
                            <input type="checkbox" id="enableRealtimeMonitoring" 
                                   ${this.realtimeMonitoring.enabled ? 'checked' : ''}>
                            启用AI视觉实时监控
                        </label>
                        <label style="font-size: 12px;">
                            监控间隔: 
                            <select id="monitoringInterval">
                                <option value="2000" ${this.realtimeMonitoring.interval === 2000 ? 'selected' : ''}>2秒</option>
                                <option value="3000" ${this.realtimeMonitoring.interval === 3000 ? 'selected' : ''}>3秒</option>
                                <option value="5000" ${this.realtimeMonitoring.interval === 5000 ? 'selected' : ''}>5秒</option>
                            </select>
                        </label>
                    </div>
                    <small>⚡ AI视觉监控可以主动发现问题并及时介入</small>
                </div>
                
                <div class="config-buttons">
                    <button onclick="testAPIConnection()" class="test-btn">🧪 测试连接</button>
                    <button onclick="saveAPIConfig()" class="save-btn">💾 保存配置</button>
                    <button onclick="closeAPIConfig()" class="cancel-btn">❌ 取消</button>
                </div>
                
                <div id="connectionStatus" class="connection-status"></div>
            </div>
        `;
        
        // 设置当前选中的模型和API URL
        setTimeout(() => {
            const modelSelect = document.getElementById('apiModel');
            const urlSelect = document.getElementById('apiUrlSelect');
            const urlInput = document.getElementById('apiUrl');
            
            if (modelSelect) {
                modelSelect.value = this.apiConfig.model;
                console.log('🔧 设置模型选择:', this.apiConfig.model);
            }
            
            if (urlSelect && urlInput) {
                // 优先使用保存的urlSelect值
                const savedUrlSelect = this.apiConfig.urlSelect;
                const currentUrl = this.apiConfig.url;
                
                // 首先尝试设置保存的选择
                if (savedUrlSelect && savedUrlSelect !== 'custom') {
                    // 检查保存的选择是否仍然有效
                    let optionExists = false;
                    for (let option of urlSelect.options) {
                        if (option.value === savedUrlSelect) {
                            optionExists = true;
                            break;
                        }
                    }
                    
                    if (optionExists) {
                        urlSelect.value = savedUrlSelect;
                        console.log('🔧 恢复保存的URL选择:', savedUrlSelect);
                        
                        // 如果选择的不是自定义，更新输入框为选择的值
                        if (savedUrlSelect !== 'custom') {
                            urlInput.value = savedUrlSelect;
                        } else {
                            urlInput.value = currentUrl;
                        }
                    } else {
                        // 保存的选择无效，回退到检查当前URL
                        this.setUrlSelectByCurrentUrl(urlSelect, urlInput, currentUrl);
                    }
                } else {
                    // 没有保存的选择或选择是自定义，检查当前URL
                    this.setUrlSelectByCurrentUrl(urlSelect, urlInput, currentUrl);
                }
            }
        }, 100);
        
        document.body.appendChild(dialog);
    }
    
    // 辅助方法：根据当前URL设置选择框
    setUrlSelectByCurrentUrl(urlSelect, urlInput, currentUrl) {
        let foundOption = false;
        
        for (let option of urlSelect.options) {
            if (option.value === currentUrl && option.value !== 'custom') {
                urlSelect.value = currentUrl;
                foundOption = true;
                console.log('🔧 根据当前URL设置选择:', currentUrl);
                break;
            }
        }
        
        // 如果不在预设选项中，选择"自定义地址"
        if (!foundOption) {
            urlSelect.value = 'custom';
            console.log('🔧 设置为自定义URL:', currentUrl);
        }
        
        // 确保输入框显示正确的URL
        urlInput.value = currentUrl;
    }
    
    // 启动实时监控系统
    startRealtimeMonitoring() {
        if (!this.apiConfig.key) {
            console.log('⚠️ 无API密钥，无法启动实时监控');
            return;
        }
        
        if (this.realtimeMonitoring.enabled) {
            console.log('⚠️ 实时监控已经在运行中');
            return;
        }
        
        this.realtimeMonitoring.enabled = true;
        this.realtimeMonitoring.lastAnalysisTime = Date.now(); // 设置初始时间
        console.log('🔍 启动AI视觉实时监控系统');
        
        this.showAssistantMessage("🔍 实时监控已启动，我会持续观察你的书写过程", 0);
        
        // 启动定时监控
        this.realtimeMonitoring.monitoringTimer = setInterval(() => {
            this.performRealtimeAnalysis();
        }, this.realtimeMonitoring.interval);
        
        // 更新UI状态
        this.updateMonitoringUI();
    }
    
    // 停止实时监控
    stopRealtimeMonitoring() {
        if (this.realtimeMonitoring.monitoringTimer) {
            clearInterval(this.realtimeMonitoring.monitoringTimer);
            this.realtimeMonitoring.monitoringTimer = null;
        }
        this.realtimeMonitoring.enabled = false;
        console.log('⏹️ 实时监控已停止');
        
        // 更新UI状态
        this.updateMonitoringUI();
    }
    
    // 更新监控UI状态
    updateMonitoringUI() {
        const statusIndicator = document.getElementById('monitoringStatusIndicator');
        const aiAssistant = document.querySelector('.ai-assistant');
        
        if (statusIndicator) {
            const statusDot = statusIndicator.querySelector('.status-dot');
            const statusText = statusIndicator.querySelector('.status-text');
            
            if (this.realtimeMonitoring.enabled) {
                statusDot.className = 'status-dot online';
                statusText.textContent = '监控在线';
                
                if (this.realtimeMonitoring.isAnalyzing) {
                    statusDot.className = 'status-dot analyzing';
                    statusText.textContent = '正在分析';
                }
            } else {
                statusDot.className = 'status-dot offline';
                statusText.textContent = '监控离线';
            }
        }
        
        // 更新AI助手视觉效果
        if (aiAssistant) {
            if (this.realtimeMonitoring.enabled) {
                aiAssistant.classList.add('monitoring-active');
            } else {
                aiAssistant.classList.remove('monitoring-active');
            }
        }
    }
    
    // 执行实时分析
    async performRealtimeAnalysis() {
        if (!this.realtimeMonitoring.enabled || this.realtimeMonitoring.isAnalyzing) {
            return;
        }
        
        // 检查是否已经答对题目，如果答对了就完全停止实时分析
        if (this.answerStatus.isCorrect) {
            console.log('✅ 答案已正确，停止所有实时分析');
            this.updateCurrentStatus('答题正确 - 分析已停止');
            return;
        }
        
        // 检查用户是否有主动操作，如果有则跳过分析
        if (this.userActionState.shouldIgnoreLLMResponse) {
            console.log('⏸️ 用户有主动操作，跳过实时分析');
            this.updateCurrentStatus('等待用户操作完成');
            return;
        }
        
        // 检查API配置
        if (!this.apiConfig.key || !this.apiConfig.url) {
            console.log('⚠️ API配置不完整，跳过实时分析');
            return;
        }
        
        const now = Date.now();
        
        // 检查是否有书写内容
        if (this.strokeHistory.length === 0) {
            this.updateCurrentStatus('等待书写');
            return;
        }
        
        // 智能调用控制：检查是否有新的书写内容
        const timeSinceLastWriting = now - this.realtimeMonitoring.lastWritingTime;
        const hasRecentWriting = timeSinceLastWriting < 10000; // 10秒内有书写
        
        // 如果没有新的书写内容，控制分析频率
        if (!hasRecentWriting) {
            // 检查无书写分析的冷却时间
            const timeSinceLastNoWritingAnalysis = now - this.realtimeMonitoring.lastNoWritingAnalysisTime;
            
            if (this.realtimeMonitoring.noWritingAnalysisCount >= this.realtimeMonitoring.maxNoWritingAnalysis &&
                timeSinceLastNoWritingAnalysis < this.realtimeMonitoring.noWritingCooldown) {
                console.log('⏳ 无书写分析冷却中，跳过本次分析');
                this.updateCurrentStatus('等待书写');
                return;
            }
            
            // 如果长时间无书写（超过30秒），给出引导
            if (timeSinceLastWriting > 30000) {
                console.log('🔍 长时间无书写，提供引导');
                this.realtimeMonitoring.noWritingAnalysisCount++;
                this.realtimeMonitoring.lastNoWritingAnalysisTime = now;
                
                // 提供更细致的引导
                const question = this.questions[this.currentQuestionIndex];
                const prompt = `学生看这道题已经很久了但没有继续书写，请给出更细致的引导帮助学生开始解题：

题目：${question.content}

请直接给出第一步应该怎么做的具体指导。`;
                
                try {
                    const guidance = await this.callAI(prompt, '');
                    // 再次检查用户是否有主动操作
                    if (!this.userActionState.shouldIgnoreLLMResponse) {
                        this.showAssistantMessage(`💡 ${guidance}`, 1);
                        this.updateCurrentStatus('提供引导');
                    } else {
                        console.log('🚫 用户有主动操作，忽略LLM引导回复');
                    }
                } catch (error) {
                    if (!this.userActionState.shouldIgnoreLLMResponse) {
                        this.showAssistantMessage("💭 试着先读一遍题目，找出关键信息，然后开始写下你的思路。", 1);
                    }
                }
                return;
            }
            
            // 短时间无书写，跳过分析
            console.log('⏸️ 短时间无新书写，跳过分析');
            this.updateCurrentStatus('思考中');
            return;
        }
        
        this.realtimeMonitoring.isAnalyzing = true;
        this.updateCurrentStatus('AI分析中');
        
        console.log('🔍 执行实时书写内容分析...');
        
        try {
            const question = this.questions[this.currentQuestionIndex];
            const analysisResult = await this.analyzeWritingContent(question);
            
            // 在显示分析结果前再次检查用户是否有主动操作
            if (this.userActionState.shouldIgnoreLLMResponse) {
                console.log('🚫 用户有主动操作，忽略LLM分析结果');
                return;
            }
            
            // 保存分析结果
            this.realtimeMonitoring.lastAnalysisResult = analysisResult;
            this.realtimeMonitoring.lastAnalysisTime = Date.now();
            
            console.log('📊 AI视觉分析结果:', analysisResult);
            
            // 更新答题状态 - 如果AI确认最终答案正确，则设置为正确状态
            if (analysisResult.finalAnswerCorrect || (!analysisResult.hasError && analysisResult.confidence > 0.8)) {
                // 如果最终答案正确，设置为正确状态
                this.answerStatus.isCorrect = true;
                this.answerStatus.lastCorrectTime = Date.now();
                this.updateCurrentStatus('答案正确');
                this.showCorrectUI();
                
                // 给予鼓励并提供步骤建议（如果需要）
                if (analysisResult.errorType === '答案正确步骤待完善') {
                    this.showAssistantMessage(`🎉 答案正确！${analysisResult.suggestion}`, 0);
                } else {
                    this.showAssistantMessage(`🎉 很棒！${analysisResult.suggestion}`, 0);
                }
                
                // 重置错误计数和卡住状态
                this.realtimeMonitoring.consecutiveErrors = 0;
                this.learningState.isStuck = false;
                
                console.log('✅ 答案正确，题目状态已更新');
                
            } else {
                this.answerStatus.isCorrect = false;
                this.updateCurrentStatus('正在思考');
                
                // 检查是否需要智能干预
                this.checkForIntelligentIntervention(analysisResult);
            }
            
        } catch (error) {
            console.error('❌ 实时分析失败:', error);
            this.updateCurrentStatus('分析失败');
        } finally {
            this.realtimeMonitoring.isAnalyzing = false;
        }
    }
    
    // 分析书写内容
    async analyzeWritingContent(question) {
        const prompt = `作为专业的小学数学助教，请实时分析学生的书写内容并给出直接的指导建议。

题目：${question.content}
正确答案：${question.answer}
题目类型：${question.type}

分析重点：
1. 首先判断学生的最终答案是否正确
2. 如果最终答案正确，即使步骤不完整或有小问题，也认定为正确
3. 只有当最终答案明显错误时，才判定为有错误
4. 对于正确答案，可以给出步骤完善建议，但不要认定为错误

请用JSON格式回复：
{
    "hasError": true/false,
    "errorType": "计算错误/思路错误/格式错误/无错误/答案正确步骤待完善",
    "confidence": 0.0-1.0,
    "suggestion": "如果答案正确：'很好！建议补充解题步骤'；如果答案错误：'这里应该用减法，15-7=8'",
    "needsIntervention": true/false,
    "analysis": "详细分析",
    "finalAnswerCorrect": true/false
}`;
        
        try {
            const response = await this.callAI(prompt, '', true);
            
            // 尝试解析JSON响应
            let analysisResult;
            try {
                analysisResult = JSON.parse(response);
                
                // 确保建议是直接指导而不是询问
                if (analysisResult.suggestion && 
                    (analysisResult.suggestion.includes('吗？') || 
                     analysisResult.suggestion.includes('需要') || 
                     analysisResult.suggestion.includes('要不要'))) {
                    // 转换为直接建议
                    analysisResult.suggestion = analysisResult.suggestion
                        .replace(/需要.*吗？/, '建议你')
                        .replace(/要不要.*？/, '你应该')
                        .replace(/是否.*？/, '请');
                }
            } catch (parseError) {
                // 如果不是JSON格式，创建默认结构
                analysisResult = {
                    hasError: response.includes('错误') || response.includes('不对'),
                    errorType: '需要检查',
                    confidence: 0.5,
                    suggestion: response.replace(/.*吗？/, '建议你').replace(/需要/, '应该'),
                    needsIntervention: response.includes('错误') || response.includes('不对'),
                    analysis: response
                };
            }
            
            console.log('📊 AI视觉分析结果:', analysisResult);
            return analysisResult;
            
        } catch (error) {
            console.error('书写内容分析失败:', error);
            return {
                hasError: false,
                errorType: '分析失败',
                confidence: 0,
                suggestion: '',
                needsIntervention: false,
                analysis: '分析服务暂时不可用'
            };
        }
    }
    
    // 检查智能介入条件
    checkForIntelligentIntervention(analysisResult) {
        const now = Date.now();
        
        // 如果答案已经正确，不需要干预
        if (this.answerStatus.isCorrect) {
            this.realtimeMonitoring.consecutiveErrors = 0;
            return;
        }
        
        // 检查冷却时间
        if (now - this.intelligentIntervention.lastInterventionTime < this.intelligentIntervention.interventionCooldown) {
            return;
        }
        
        // 检查是否需要介入
        if (analysisResult.needsIntervention && analysisResult.hasError && analysisResult.confidence > 0.6) {
            // 更新连续错误计数
            this.realtimeMonitoring.consecutiveErrors++;
            
            // 达到介入阈值
            if (this.realtimeMonitoring.consecutiveErrors >= this.intelligentIntervention.errorThreshold) {
                this.performIntelligentIntervention(analysisResult);
                this.realtimeMonitoring.consecutiveErrors = 0;
            }
        } else if (!analysisResult.hasError) {
            // 重置错误计数
            this.realtimeMonitoring.consecutiveErrors = 0;
        }
    }
    
    // 执行智能介入
    performIntelligentIntervention(analysisResult) {
        console.log('🚨 执行智能介入:', analysisResult);
        
        this.intelligentIntervention.lastInterventionTime = Date.now();
        
        // 直接介入，不询问
        setTimeout(() => {
            this.showAssistantMessage("⚠️ 我发现你的解题过程中有个小问题...", 2);
            
            setTimeout(() => {
                this.showAssistantMessage(`💡 ${analysisResult.suggestion}`, 3);
            }, 2000);
            
            // 如果错误比较严重，提供更详细的指导
            if (analysisResult.confidence > 0.8) {
                setTimeout(() => {
                    this.showAssistantMessage("让我们一起重新思考这个问题吧！", 2);
                }, 4000);
            }
        }, this.intelligentIntervention.interventionDelay);
        
        // 更新UI状态
        this.updateCurrentStatus('智能介入中');
        document.querySelector('.ai-assistant').classList.add('urgent');
        
        // 5秒后移除紧急状态
        setTimeout(() => {
            document.querySelector('.ai-assistant').classList.remove('urgent');
        }, 5000);
    }
    
    // 检查实时监控健康状态
    checkRealtimeMonitoringHealth() {
        if (!this.realtimeMonitoring.enabled) return;
        
        const now = Date.now();
        const timeSinceLastAnalysis = now - this.realtimeMonitoring.lastAnalysisTime;
        
        // 只有在初始化后且有书写内容时才检查停滞
        // 避免在没有API密钥或没有书写内容时误判
        if (this.realtimeMonitoring.lastAnalysisTime > 0 && 
            timeSinceLastAnalysis > 60000 && 
            this.strokeHistory.length > 0 && 
            this.apiConfig.key) {
            console.log('⚠️ 实时监控可能停滞，尝试重启...');
            this.restartRealtimeMonitoring();
        }
    }
    
    // 重启实时监控
    restartRealtimeMonitoring() {
        this.stopRealtimeMonitoring();
        setTimeout(() => {
            this.startRealtimeMonitoring();
            this.showAssistantMessage("🔄 实时监控已重启", 0);
        }, 1000);
    }
    
    // 初始化时加载保存的监控设置
    loadMonitoringSettings() {
        const enabledSetting = localStorage.getItem('realtime_monitoring_enabled');
        const intervalSetting = localStorage.getItem('monitoring_interval');
        
        if (enabledSetting === 'true' && this.apiConfig.key) {
            this.realtimeMonitoring.interval = parseInt(intervalSetting) || 5000;
            // 延迟启动，确保系统完全初始化
            setTimeout(() => {
                this.startRealtimeMonitoring();
            }, 3000);
        }
    }
    
    // 安全的状态更新方法
    updateCurrentStatus(status) {
        // 尝试更新状态元素，如果不存在则忽略
        const statusElement = document.getElementById('currentStatus');
        if (statusElement) {
            statusElement.textContent = status;
        }
        
        // 同时在控制台输出状态，便于调试
        console.log(`📊 学习状态: ${status}`);
    }
    
    // 更新监控状态指示器
    updateMonitoringStatus(status, type = 'online') {
        const statusIndicator = document.querySelector('.monitoring-status .status-indicator');
        if (statusIndicator) {
            statusIndicator.innerHTML = `
                <span class="status-dot ${type}"></span>
                ${status}
            `;
        }
        console.log(`🔍 监控状态: ${status} (${type})`);
    }
    
    // 显示答题正确的UI状态
    showCorrectUI() {
        // 题目区域添加正确状态
        const questionContent = document.querySelector('.question-content');
        if (questionContent) {
            questionContent.classList.add('correct');
        }
        
        // 画布区域添加正确状态
        const writingArea = document.querySelector('.writing-area');
        if (writingArea) {
            writingArea.classList.add('correct');
        }
        
        // AI助手添加成功状态
        const aiAssistant = document.querySelector('.ai-assistant');
        if (aiAssistant) {
            aiAssistant.classList.add('success');
            // 3秒后移除成功动画
            setTimeout(() => {
                aiAssistant.classList.remove('success');
            }, 3000);
        }
        
        // 更新监控状态面板为"答题正确"状态
        const statusIndicator = document.getElementById('monitoringStatusIndicator');
        if (statusIndicator) {
            const statusDot = statusIndicator.querySelector('.status-dot');
            const statusText = statusIndicator.querySelector('.status-text');
            if (statusDot && statusText) {
                statusDot.className = 'status-dot correct';
                statusText.textContent = '答题正确';
            }
        }
        
        console.log('✅ 显示答题正确UI状态');
    }
    
    // 清除答题正确的UI状态
    clearCorrectUI() {
        // 移除题目区域的正确状态
        const questionContent = document.querySelector('.question-content');
        if (questionContent) {
            questionContent.classList.remove('correct');
        }
        
        // 移除画布区域的正确状态
        const writingArea = document.querySelector('.writing-area');
        if (writingArea) {
            writingArea.classList.remove('correct');
        }
        
        // 移除AI助手的成功状态
        const aiAssistant = document.querySelector('.ai-assistant');
        if (aiAssistant) {
            aiAssistant.classList.remove('success');
        }
        
        // 重置监控状态面板显示
        const statusIndicator = document.getElementById('monitoringStatusIndicator');
        if (statusIndicator) {
            const statusDot = statusIndicator.querySelector('.status-dot');
            const statusText = statusIndicator.querySelector('.status-text');
            if (statusDot && statusText) {
                // 根据当前监控状态设置正确的显示
                if (this.realtimeMonitoring.enabled) {
                    statusDot.className = 'status-dot running';
                    statusText.textContent = '监控运行中';
                } else {
                    statusDot.className = 'status-dot offline';
                    statusText.textContent = '监控离线';
                }
            }
        }
        
        console.log('🔄 清除答题正确UI状态');
    }
    
    // 监控状态诊断工具
    diagnoseMonitoringStatus() {
        const now = Date.now();
        const timeSinceLastAnalysis = now - this.realtimeMonitoring.lastAnalysisTime;
        const timeSinceLastWriting = now - this.realtimeMonitoring.lastWritingTime;
        
        console.log('🔍 ===== 监控状态诊断报告 =====');
        console.log(`📊 基础状态:`);
        console.log(`   - 监控启用: ${this.realtimeMonitoring.enabled}`);
        console.log(`   - 定时器存在: ${!!this.realtimeMonitoring.monitoringTimer}`);
        console.log(`   - 正在分析: ${this.realtimeMonitoring.isAnalyzing}`);
        console.log(`   - API密钥: ${!!this.apiConfig.key}`);
        console.log(`   - API地址: ${this.apiConfig.url}`);
        
        console.log(`📝 书写状态:`);
        console.log(`   - 笔画数量: ${this.strokeHistory.length}`);
        console.log(`   - 最后书写时间: ${this.realtimeMonitoring.lastWritingTime ? new Date(this.realtimeMonitoring.lastWritingTime).toLocaleTimeString() : '未记录'}`);
        console.log(`   - 距离最后书写: ${Math.floor(timeSinceLastWriting / 1000)}秒`);
        console.log(`   - 已开始书写: ${this.answerStatus.hasStartedWriting}`);
        
        console.log(`🤖 分析状态:`);
        console.log(`   - 最后分析时间: ${this.realtimeMonitoring.lastAnalysisTime ? new Date(this.realtimeMonitoring.lastAnalysisTime).toLocaleTimeString() : '未分析'}`);
        console.log(`   - 距离最后分析: ${Math.floor(timeSinceLastAnalysis / 1000)}秒`);
        console.log(`   - 无书写分析次数: ${this.realtimeMonitoring.noWritingAnalysisCount}`);
        console.log(`   - 最后无书写分析: ${this.realtimeMonitoring.lastNoWritingAnalysisTime ? new Date(this.realtimeMonitoring.lastNoWritingAnalysisTime).toLocaleTimeString() : '未记录'}`);
        
        console.log(`✅ 答题状态:`);
        console.log(`   - 答案正确: ${this.answerStatus.isCorrect}`);
        console.log(`   - 最后正确时间: ${this.answerStatus.lastCorrectTime ? new Date(this.answerStatus.lastCorrectTime).toLocaleTimeString() : '未答对'}`);
        console.log(`   - 连续错误次数: ${this.realtimeMonitoring.consecutiveErrors}`);
        
        console.log(`🎯 监控决策逻辑:`);
        const hasRecentWriting = timeSinceLastWriting < 10000;
        const isInCooldown = this.realtimeMonitoring.noWritingAnalysisCount >= this.realtimeMonitoring.maxNoWritingAnalysis && 
                            (now - this.realtimeMonitoring.lastNoWritingAnalysisTime) < this.realtimeMonitoring.noWritingCooldown;
        const isCorrectAndRecent = this.answerStatus.isCorrect && (now - this.answerStatus.lastCorrectTime) < 60000;
        
        console.log(`   - 有近期书写 (10秒内): ${hasRecentWriting}`);
        console.log(`   - 在冷却期中: ${isInCooldown}`);
        console.log(`   - 答对且在60秒内: ${isCorrectAndRecent}`);
        console.log(`   - 长时间无书写 (>30秒): ${timeSinceLastWriting > 30000}`);
        
        console.log(`🚨 可能的停止原因:`);
        if (isCorrectAndRecent) {
            console.log(`   ✅ 答题正确，系统已停止监控 (设计行为)`);
        } else if (!hasRecentWriting && isInCooldown) {
            console.log(`   ⏳ 无书写分析达到上限，进入冷却期`);
        } else if (!hasRecentWriting && timeSinceLastWriting <= 30000) {
            console.log(`   ⏸️ 短时间无新书写，跳过分析 (设计行为)`);
        } else if (this.strokeHistory.length === 0) {
            console.log(`   📝 无书写内容，等待学生开始书写`);
        } else if (!this.apiConfig.key) {
            console.log(`   🔑 缺少API密钥，无法进行分析`);
        } else if (this.realtimeMonitoring.isAnalyzing) {
            console.log(`   🔄 正在分析中，等待结果`);
        } else {
            console.log(`   ❓ 未知原因，可能需要重启监控`);
        }
        
        console.log('🔍 ===== 诊断报告结束 =====');
        
        return {
            enabled: this.realtimeMonitoring.enabled,
            hasTimer: !!this.realtimeMonitoring.monitoringTimer,
            isAnalyzing: this.realtimeMonitoring.isAnalyzing,
            hasApiKey: !!this.apiConfig.key,
            strokeCount: this.strokeHistory.length,
            timeSinceLastWriting: Math.floor(timeSinceLastWriting / 1000),
            timeSinceLastAnalysis: Math.floor(timeSinceLastAnalysis / 1000),
            isCorrect: this.answerStatus.isCorrect,
            hasRecentWriting,
            isInCooldown,
            isCorrectAndRecent
        };
    }
}

// 初始化应用
document.addEventListener('DOMContentLoaded', function() {
    console.log('🚀 页面加载完成，初始化AI助教系统...');
    window.mathTutor = new MathTutorAI();
    
    // 确保全局访问
    window.tutorAI = window.mathTutor; // 保持向后兼容
});

// 全局函数 - 面板控制
function closeDemoPanel() {
    const panel = document.getElementById('demoPanel');
    const toggleBtn = document.getElementById('demoToggleBtn');
    panel.classList.add('hidden');
    // 演示按钮始终显示，不需要控制
}

function toggleDemoPanel() {
    const panel = document.getElementById('demoPanel');
    const toggleText = document.getElementById('demoToggleText');
    
    if (panel.classList.contains('hidden')) {
        panel.classList.remove('hidden');
        toggleText.textContent = '关闭演示指南';
    } else {
        panel.classList.add('hidden');
        toggleText.textContent = '打开演示指南';
    }
}

// 全局函数 - API配置
function saveAPIConfig() {
    const apiUrl = document.getElementById('apiUrl').value.trim();
    const apiKey = document.getElementById('apiKey').value.trim();
    const apiModel = document.getElementById('apiModel').value;
    const apiUrlSelect = document.getElementById('apiUrlSelect').value;
    const enableRealtimeMonitoring = document.getElementById('enableRealtimeMonitoring').checked;
    const monitoringInterval = parseInt(document.getElementById('monitoringInterval').value);
    
    if (!apiUrl || !apiKey) {
        alert('请填写完整的API配置信息！');
        return;
    }
    
    console.log('💾 保存配置:', {
        url: apiUrl,
        model: apiModel,
        urlSelect: apiUrlSelect,
        monitoring: enableRealtimeMonitoring
    });
    
    // 保存到localStorage
    localStorage.setItem('api_url', apiUrl);
    localStorage.setItem('api_key', apiKey);
    localStorage.setItem('api_model', apiModel);
    localStorage.setItem('api_url_select', apiUrlSelect); // 新增：保存URL选择
    localStorage.setItem('realtime_monitoring_enabled', enableRealtimeMonitoring.toString());
    localStorage.setItem('monitoring_interval', monitoringInterval.toString());
    
    // 更新当前实例的配置
    if (window.mathTutor) {
        window.mathTutor.apiConfig.url = apiUrl;
        window.mathTutor.apiConfig.key = apiKey;
        window.mathTutor.apiConfig.model = apiModel;
        window.mathTutor.apiConfig.urlSelect = apiUrlSelect;
        
        // 应用实时监控设置
        const wasEnabled = window.mathTutor.realtimeMonitoring.enabled;
        window.mathTutor.realtimeMonitoring.interval = monitoringInterval;
        
        if (enableRealtimeMonitoring && !wasEnabled) {
            // 启用实时监控
            window.mathTutor.startRealtimeMonitoring();
        } else if (!enableRealtimeMonitoring && wasEnabled) {
            // 禁用实时监控
            window.mathTutor.stopRealtimeMonitoring();
            window.mathTutor.showAssistantMessage("🔍 实时监控已关闭", 0);
        } else if (enableRealtimeMonitoring && wasEnabled) {
            // 重启监控以应用新的间隔设置
            window.mathTutor.restartRealtimeMonitoring();
        }
        
        window.mathTutor.showAssistantMessage("✅ 配置已保存并应用！", 0);
    }
    
    closeAPIConfig();
}

// 新增：更新API URL选择
function updateApiUrl() {
    const select = document.getElementById('apiUrlSelect');
    const input = document.getElementById('apiUrl');
    
    if (select.value !== 'custom') {
        input.value = select.value;
    }
}

function closeAPIConfig() {
    const dialog = document.getElementById('apiConfigDialog');
    if (dialog) {
        dialog.remove();
    }
}

async function testAPIConnection() {
    const apiUrl = document.getElementById('apiUrl').value.trim();
    const apiKey = document.getElementById('apiKey').value.trim();
    const apiModel = document.getElementById('apiModel').value;
    const statusDiv = document.getElementById('connectionStatus');
    
    if (!apiUrl || !apiKey) {
        statusDiv.innerHTML = '<span style="color: red;">❌ 请先填写API地址和密钥</span>';
        return;
    }
    
    statusDiv.innerHTML = '<span style="color: blue;">🔄 正在测试连接...</span>';
    
    // 检测是否是火山方舟API
    const isVolcesAPI = apiUrl.includes('ark.cn-beijing.volces.com');
    
    try {
        // 构建正确的API URL
        let testUrl = apiUrl;
        if (isVolcesAPI && !testUrl.endsWith('/chat/completions')) {
            testUrl = testUrl.endsWith('/') ? testUrl + 'chat/completions' : testUrl + '/chat/completions';
        }
        
        const testMessage = {
            model: apiModel,
            messages: [
                {
                    role: 'user',
                    content: '你好，请回复"连接成功"'
                }
            ],
            max_tokens: 50
        };
        
        const response = await fetch(testUrl, {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(testMessage)
        });
        
        if (response.ok) {
            const data = await response.json();
            if (data.choices && data.choices[0] && data.choices[0].message) {
                statusDiv.innerHTML = '<span style="color: green;">✅ 连接成功！模型响应正常</span>';
                
                // 检测是否为豆包模型
                if (apiModel.toLowerCase().includes('doubao') || apiModel.toLowerCase().includes('ui-tars')) {
                    statusDiv.innerHTML += '<br><span style="color: blue;">🚀 检测到豆包模型，已启用专项优化</span>';
                }
            } else {
                statusDiv.innerHTML = '<span style="color: orange;">⚠️ 连接成功但响应格式异常</span>';
            }
        } else {
            const errorText = await response.text();
            statusDiv.innerHTML = `<span style="color: red;">❌ 连接失败: ${response.status} - ${errorText.substring(0, 100)}</span>`;
        }
    } catch (error) {
        if (error.message.includes('CORS') || error.message.includes('fetch')) {
            statusDiv.innerHTML = `<span style="color: orange;">⚠️ 跨域限制: 浏览器阻止了请求</span><br>
                                  <span style="color: blue;">💡 解决方案：</span><br>
                                  <span style="color: gray;">1. 使用代理服务器</span><br>
                                  <span style="color: gray;">2. 部署到服务器环境</span><br>
                                  <span style="color: gray;">3. 使用支持CORS的API服务</span>`;
        } else {
            statusDiv.innerHTML = `<span style="color: red;">❌ 连接错误: ${error.message}</span>`;
        }
    }
}

// 全局诊断函数
function diagnoseMonitoring() {
    if (window.mathTutor) {
        return window.mathTutor.diagnoseMonitoringStatus();
    } else {
        console.log('❌ 系统未初始化');
        return null;
    }
}

// 全局函数 - 面板控制